diff --git a/.gitignore b/.gitignore
index c3441050..48e3da60 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,32 +11,32 @@ __pycache__/
 .pytest_cache/
 .benchmarks/
 *.cpp
-!cuda/_lib/param_packer.cpp
-!cuda/_cuda/loader.cpp
+!cuda/cuda/bindings/_lib/param_packer.cpp
+!cuda/cuda/bindings/_bindings/loader.cpp
 
 # CUDA Python specific (auto-generated)
-cuda/_cuda/ccuda.pxd
-cuda/_cuda/ccuda.pyx
-cuda/_cuda/cnvrtc.pxd
-cuda/_cuda/cnvrtc.pyx
-cuda/_lib/ccudart/ccudart.pxd
-cuda/_lib/ccudart/ccudart.pyx
-cuda/_lib/ccudart/utils.pxd
-cuda/_lib/ccudart/utils.pyx
-cuda/_lib/utils.pxd
-cuda/_lib/utils.pyx
-cuda/ccuda.pxd
-cuda/ccuda.pyx
-cuda/ccudart.pxd
-cuda/ccudart.pyx
-cuda/cnvrtc.pxd
-cuda/cnvrtc.pyx
-cuda/cuda.pxd
-cuda/cuda.pyx
-cuda/cudart.pxd
-cuda/cudart.pyx
-cuda/nvrtc.pxd
-cuda/nvrtc.pyx
+cuda/cuda/bindings/_bindings/cydriver.pxd
+cuda/cuda/bindings/_bindings/cydriver.pyx
+cuda/cuda/bindings/_bindings/cynvrtc.pxd
+cuda/cuda/bindings/_bindings/cynvrtc.pyx
+cuda/cuda/bindings/_lib/cyruntime/cyruntime.pxd
+cuda/cuda/bindings/_lib/cyruntime/cyruntime.pyx
+cuda/cuda/bindings/_lib/cyruntime/utils.pxd
+cuda/cuda/bindings/_lib/cyruntime/utils.pyx
+cuda/cuda/bindings/_lib/utils.pxd
+cuda/cuda/bindings/_lib/utils.pyx
+cuda/cuda/bindings/cydriver.pxd
+cuda/cuda/bindings/cydriver.pyx
+cuda/cuda/bindings/cyruntime.pxd
+cuda/cuda/bindings/cyruntime.pyx
+cuda/cuda/bindings/cynvrtc.pxd
+cuda/cuda/bindings/cynvrtc.pyx
+cuda/cuda/bindings/driver.pxd
+cuda/cuda/bindings/driver.pyx
+cuda/cuda/bindings/runtime.pxd
+cuda/cuda/bindings/runtime.pyx
+cuda/cuda/bindings/nvrtc.pxd
+cuda/cuda/bindings/nvrtc.pyx
 
 # Distribution / packaging
 .Python
@@ -168,3 +168,6 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
+
+# Dont ignore
+!.github/actions/build/
diff --git a/MANIFEST.in b/MANIFEST.in
deleted file mode 100644
index 4e93de45..00000000
--- a/MANIFEST.in
+++ /dev/null
@@ -1 +0,0 @@
-include cuda/_version.py
diff --git a/continuous_integration/environment.yml b/continuous_integration/environment.yml
new file mode 100644
index 00000000..6d922d43
--- /dev/null
+++ b/continuous_integration/environment.yml
@@ -0,0 +1,24 @@
+name: cuda_python
+channels:
+  - defaults
+dependencies:
+  - python>=3.10
+  - cython>=3.0.0
+  - pytest>=6.2.4
+  - numpy>=1.21.1
+  - setuptools
+  - wheel
+  - pip
+  - cuda-version=12.6
+  - cuda-cudart-static
+  - cuda-driver-dev
+  - cuda-cudart-dev
+  - cuda-profiler-api
+  - cuda-nvrtc-dev
+  - cuda-nvcc
+  - pip:
+    - pytest-benchmark>=3.4.1
+    - pyclibrary>=0.1.7
+    - versioneer==0.29
+    - tomli; python_version < "3.11"
+    - pywin32; sys_platform == 'win32'
diff --git a/continuous_integration/no_dependencies.json b/continuous_integration/no_dependencies.json
new file mode 100644
index 00000000..e2d7bd79
--- /dev/null
+++ b/continuous_integration/no_dependencies.json
@@ -0,0 +1 @@
+{ "packages" : {} }
diff --git a/continuous_integration/scripts/build b/continuous_integration/scripts/build
new file mode 100755
index 00000000..5db25e67
--- /dev/null
+++ b/continuous_integration/scripts/build
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+build_ci() {
+    set -xeou pipefail
+
+    cd "${REPO_DIR}"
+
+    export CUDA_HOME="${CONDA_PREFIX}/targets/x86_64-linux"
+    export PARALLEL_LEVEL=$(nproc --ignore 1)
+
+    python setup.py bdist_wheel
+}
+
+build_project() {
+    set -xeou pipefail
+
+    export PYTHONUNBUFFERED=1
+
+    . setup-utils;
+    init_build_env "$@";
+
+    git config --global --add safe.directory "$REPO_DIR/.git"
+
+    case "${BUILD_TYPE}" in
+        ci) build_ci;;
+        *) return 1;;
+    esac
+}
+
+(build_project "$@");
diff --git a/continuous_integration/scripts/conda-utils b/continuous_integration/scripts/conda-utils
new file mode 100755
index 00000000..e0dd32ca
--- /dev/null
+++ b/continuous_integration/scripts/conda-utils
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+activate_conda_env() {
+    set +xu
+    eval "$(conda shell.bash hook)"
+    conda activate "${CONDA_ENV}";
+    set -xu
+    : ${PYTHON_VERSION:=$(python -c "import sys; print(f'{sys.version_info.major}.{sys.version_info.minor}')")}
+    export PYTHON_VERSION
+}
+
+conda_info() {
+    set +x
+    conda info
+    set -x
+}
diff --git a/continuous_integration/scripts/entrypoint b/continuous_integration/scripts/entrypoint
new file mode 100755
index 00000000..fe4f5cea
--- /dev/null
+++ b/continuous_integration/scripts/entrypoint
@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+set_initial_env() {
+    set -xeuo pipefail
+
+    export PATH="${PATH}:${REPO_DIR}/continuous_integration/scripts"
+}
+
+entrypoint() {
+    set -xeuo pipefail
+    set_initial_env;
+
+    git config --global --add safe.directory "$REPO_DIR/.git"
+
+    cd "${REPO_DIR}"
+
+    exec "$@";
+}
+
+entrypoint "$@";
diff --git a/continuous_integration/scripts/make-conda-env b/continuous_integration/scripts/make-conda-env
new file mode 100755
index 00000000..1294f038
--- /dev/null
+++ b/continuous_integration/scripts/make-conda-env
@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+
+set -x
+
+make_ci_env() {
+    mamba env create -n "${CONDA_ENV}" -f "${REPO_DIR}/continuous_integration/environment.yml"
+}
+
+make_test_env() {
+    . conda-utils
+
+    mamba env create -n "${CONDA_ENV}" -f "${REPO_DIR}/continuous_integration/environment.yml"
+
+    activate_conda_env
+
+    pip install "${ARTIFACTS_DIR}"/*.whl
+
+}
+
+make_conda_env() {
+    set -xeuo pipefail
+
+    . setup-utils;
+    set_base_defs;
+
+    case "$1" in
+        ci) make_ci_env;;
+        test) make_test_env;;
+        *) return 1;;
+    esac
+
+    return 0;
+}
+
+(make_conda_env "$@");
diff --git a/continuous_integration/scripts/render-template.py b/continuous_integration/scripts/render-template.py
new file mode 100755
index 00000000..b887e361
--- /dev/null
+++ b/continuous_integration/scripts/render-template.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+
+import argparse
+import json
+from jinja2 import Environment, FileSystemLoader
+import os
+import re
+
+# TODO: make this work for arbitrary context. ie. implement replace_using_context()
+def replace_placeholder(source_str, variable_name, variable_value):
+    # Escaping any regex special characters in variable_name
+    variable_name_escaped = re.escape(variable_name)
+
+    # Using regular expression to replace ${variable_name} with actual variable_value
+    # \s* means any amount of whitespace (including none)
+    # pattern = rf'\$\{{\s*\{{\s*{variable_name_escaped}\s*\}}\s*\}}'
+    pattern = rf'<<\s*{variable_name_escaped}\s*>>'
+    return re.sub(pattern, variable_value.strip(), source_str)
+
+# Setup command-line argument parsing
+parser = argparse.ArgumentParser(description='Render a Jinja2 template using a JSON context.')
+parser.add_argument('template_file', type=str, help='Path to the Jinja2 template file (with .j2 extension).')
+parser.add_argument('json_file', type=str, help='Path to the JSON file to use as the rendering context.')
+parser.add_argument('output_file', type=str, help='Path to the output file.')
+
+args = parser.parse_args()
+
+# Load JSON file as the rendering context
+with open(args.json_file, 'r') as file:
+    context = json.load(file)
+
+# Setup Jinja2 environment and load the template
+env = Environment(
+    loader=FileSystemLoader(searchpath='./'),
+    variable_start_string='<<',
+    variable_end_string='>>',
+    block_start_string='<%',
+    block_end_string='%>',
+    comment_start_string='<#',
+    comment_end_string='#>')
+env.filters['replace_placeholder'] = replace_placeholder
+
+template = env.get_template(args.template_file)
+
+# Render the template with the context
+rendered_content = template.render(context)
+# print(rendered_content)
+
+with open(args.output_file, 'w') as file:
+    file.write(rendered_content)
+
+print(f'Template rendered successfully. Output saved to {args.output_file}')
diff --git a/continuous_integration/scripts/setup-utils b/continuous_integration/scripts/setup-utils
new file mode 100755
index 00000000..62579e63
--- /dev/null
+++ b/continuous_integration/scripts/setup-utils
@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+
+install_from_apt() {
+    set -xeuo pipefail
+
+    export DEBIAN_FRONTEND=non-interactive
+
+    # Run package updates and install packages
+    apt-get -q update
+    apt-get -q install -y wget curl jq sudo ninja-build vim numactl rsync
+}
+
+install_cmake() {
+    set -xeuo pipefail
+
+    wget -q https://github.com/Kitware/CMake/releases/download/v3.26.5/cmake-3.26.5-linux-x86_64.tar.gz
+
+    tar -xzf cmake-3.26.5-linux-x86_64.tar.gz
+}
+
+setup_linux_build_env() {
+    set -xeuo pipefail
+    export OS_SHORT_NAME=linux
+    export PATH="${PATH}:${PREBUILD_DIR}/cmake-3.26.5-linux-x86_64/bin"
+
+    mkdir -p /tmp/out /tmp/env_yaml
+}
+
+install_linux_tools() {
+    set -xeuo pipefail
+
+    export SED=sed
+    export READLINK=readlink
+
+    install_from_apt;
+    install_cmake;
+
+    mkdir -p /tmp/out /tmp/env_yaml
+}
+
+install_linux_test_tools() {
+    set -xeuo pipefail
+
+    export SED=sed
+    export READLINK=readlink
+
+    # Run package updates and install packages
+    apt-get -q update
+    apt-get -q install -y numactl
+}
+
+set_base_defs() {
+    set -xeuo pipefail
+
+    export CONDA_ENV=cuda_python
+
+    CONDA_PLATFORM=$(conda info | grep 'platform' | awk -F ' : ' '{print $2}')
+    export CONDA_PLATFORM
+
+    export PREBUILD_DIR=/tmp/prebuild
+    mkdir -p "$PREBUILD_DIR"
+
+    export BUILD_DIR="$REPO_DIR/build"
+
+    # Get the machine architecture
+    ARCH=$(uname -m)
+
+    if [ "$ARCH" == "aarch64" ]; then
+        # Use the gcc march value used by aarch64 Ubuntu.
+        BUILD_MARCH=armv8-a
+    else
+        # Use uname -m otherwise
+        BUILD_MARCH=$(uname -m | tr '_' '-')
+    fi
+
+    export BUILD_MARCH
+
+    export CUDA_VERSION=12.2.2
+
+    export MAX_LIBSANITIZER_VERSION=11.4
+
+    export USE_OPENMP=ON
+}
+
+# -----------------------------------------------------------------------------
+
+prep_git() {
+    # Temporarily disable exit on error
+    set +e
+    git config --global user.email > /dev/null
+    local email_exit_status=$?
+    git config --global user.name > /dev/null
+    local name_exit_status=$?
+    # Re-enable exit on error
+    set -e
+
+    if [ $email_exit_status -ne 0 ]; then
+        git config --global --add user.email "users.noreply.github.com"
+        echo "git user.email was not set. It's now set to users.noreply.github.com"
+    else
+        echo "Note: git user.email is already set."
+    fi
+
+    if [ $name_exit_status -ne 0 ]; then
+        git config --global --add user.name "anon"
+        echo "git user.name was not set. It's now set to anon"
+    else
+        echo "Note: git user.name is already set."
+    fi
+
+    # Fix "fatal: detected dubious ownership in repository at '/tmp/legate.core'"
+    # during local builds.
+    git config --global --add safe.directory "$REPO_DIR"
+}
+
+
+setup_build_env() {
+    set -xeuo pipefail
+
+    install_linux_tools;
+
+    setup_linux_build_env;
+
+    rm -rf "$PREBUILD_DIR"
+    mkdir -p "$PREBUILD_DIR"
+    cd $PREBUILD_DIR
+
+    prep_git;
+}
+
+init_build_env() {
+    set -x;
+
+    . conda-utils;
+
+    export BUILD_TYPE=$1
+
+    set -xeuo pipefail;
+
+    set_base_defs;
+
+    cd "$PREBUILD_DIR"
+
+    setup_build_env;
+
+    cd "$REPO_DIR";
+
+    if [[ -d "${BUILD_DIR}" ]]; then
+        rm -rf "${BUILD_DIR}"
+    fi
+
+    make-conda-env "$BUILD_TYPE";
+
+    activate_conda_env;
+    conda_info;
+}
\ No newline at end of file
diff --git a/cuda/LICENSE b/cuda/LICENSE
new file mode 100644
index 00000000..b7d042fc
--- /dev/null
+++ b/cuda/LICENSE
@@ -0,0 +1,48 @@
+NVIDIA SOFTWARE LICENSE
+
+This license is a legal agreement between you and NVIDIA Corporation ("NVIDIA") and governs your use of the NVIDIA CUDA Python software and materials provided hereunder ("SOFTWARE").
+
+This license can be accepted only by an adult of legal age of majority in the country in which the SOFTWARE is used. If you are under the legal age of majority, you must ask your parent or legal guardian to consent to this license. By taking delivery of the SOFTWARE, you affirm that you have reached the legal age of majority, you accept the terms of this license, and you take legal and financial responsibility for the actions of your permitted users. 
+
+You agree to use the SOFTWARE only for purposes that are permitted by (a) this license, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions.
+
+1. LICENSE. Subject to the terms of this license, NVIDIA grants you a non-exclusive limited license to: (a) install and use the SOFTWARE, and (b) distribute the SOFTWARE subject to the distribution requirements described in this license. NVIDIA reserves all rights, title and interest in and to the SOFTWARE not expressly granted to you under this license.
+
+2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the distribution grant: 
+a.  The terms under which you distribute the SOFTWARE must be consistent with the terms of this license, including (without limitation) terms relating to the license grant and license restrictions and protection of NVIDIA's intellectual property rights. 
+b.  You agree to notify NVIDIA in writing of any known or suspected distribution or use of the SOFTWARE not in compliance with the requirements of this license, and to enforce the terms of your agreements with respect to distributed SOFTWARE. 
+
+3. LIMITATIONS. Your license to use the SOFTWARE is restricted as follows:
+a.  The SOFTWARE is licensed for you to develop applications only for use in systems with NVIDIA GPUs.
+b.  You may not reverse engineer, decompile or disassemble, or remove copyright or other proprietary notices from any portion of the SOFTWARE or copies of the SOFTWARE. 
+c.  You may not modify or create derivative works of any portion of the SOFTWARE. 
+d.  You may not bypass, disable, or circumvent any technical measure, encryption, security, digital rights management or authentication mechanism in the SOFTWARE.
+e.  You may not use the SOFTWARE in any manner that would cause it to become subject to an open source software license. As examples, licenses that require as a condition of use, modification, and/or distribution that the SOFTWARE be (i) disclosed or distributed in source code form; (ii) licensed for the purpose of making derivative works; or (iii) redistributable at no charge.
+f.  Unless you have an agreement with NVIDIA for this purpose, you may not use the SOFTWARE with any system or application where the use or failure of the system or application can reasonably be expected to threaten or result in personal injury, death, or catastrophic loss. Examples include use in avionics, navigation, military, medical, life support or other life critical applications. NVIDIA does not design, test or manufacture the SOFTWARE for these critical uses and NVIDIA shall not be liable to you or any third party, in whole or in part, for any claims or damages arising from such uses. 
+g.  You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their respective employees, contractors, agents, officers and directors, from and against any and all claims, damages, obligations, losses, liabilities, costs or debt, fines, restitutions and expenses (including but not limited to attorney's fees and costs incident to establishing the right of indemnification) arising out of or related to use of the SOFTWARE outside of the scope of this Agreement, or not in compliance with its terms. 
+
+4. PRE-RELEASE. SOFTWARE versions identified as alpha, beta, preview, early access or otherwise as pre-release may not be fully functional, may contain errors or design flaws, and may have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials. You may use a pre-release SOFTWARE version at your own risk, understanding that these versions are not intended for use in production or business-critical systems. 
+
+5. OWNERSHIP. The SOFTWARE and the related intellectual property rights therein are and will remain the sole and exclusive property of NVIDIA or its licensors. The SOFTWARE is copyrighted and protected by the laws of the United States and other countries, and international treaty provisions. NVIDIA may make changes to the SOFTWARE, at any time without notice, but is not obligated to support or update the SOFTWARE.
+ 
+6. COMPONENTS UNDER OTHER LICENSES. The SOFTWARE may include NVIDIA or third-party components with separate legal notices or terms as may be described in proprietary notices accompanying the SOFTWARE. If and to the extent there is a conflict between the terms in this license and the license terms associated with a component, the license terms associated with the components control only to the extent necessary to resolve the conflict.  
+
+7. FEEDBACK. You may, but don't have to, provide to NVIDIA any Feedback. "Feedback" means any suggestions, bug fixes, enhancements, modifications, feature requests or other feedback regarding the SOFTWARE. For any Feedback that you voluntarily provide, you hereby grant NVIDIA and its affiliates a perpetual, non-exclusive, worldwide, irrevocable license to use, reproduce, modify, license, sublicense (through multiple tiers of sublicensees), and distribute (through multiple tiers of distributors) the Feedback without the payment of any royalties or fees to you. NVIDIA will use Feedback at its choice.
+
+8. NO WARRANTIES. THE SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. NVIDIA DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS OR THAT THE OPERATION THEREOF WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ALL ERRORS WILL BE CORRECTED. 
+
+9. LIMITATIONS OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, PROJECT DELAYS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION WITH THIS LICENSE OR THE USE OR PERFORMANCE OF THE SOFTWARE, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF LIABILITY, EVEN IF NVIDIA HAS PREVIOUSLY BEEN ADVISED OF, OR COULD REASONABLY HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL NVIDIA'S AND ITS AFFILIATES TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS LICENSE EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT. 
+
+10. TERMINATION. Your rights under this license will terminate automatically without notice from NVIDIA if you fail to comply with any term and condition of this license or if you commence or participate in any legal proceeding against NVIDIA with respect to the SOFTWARE. NVIDIA may terminate this license with advance written notice to you if NVIDIA decides to no longer provide the SOFTWARE in a country or, in NVIDIA's sole discretion, the continued use of it is no longer commercially viable. Upon any termination of this license, you agree to promptly discontinue use of the SOFTWARE and destroy all copies in your possession or control. Your prior distributions in accordance with this license are not affected by the termination of this license. All provisions of this license will survive termination, except for the license granted to you.  
+
+11. APPLICABLE LAW. This license will be governed in all respects by the laws of the United States and of the State of Delaware as those laws are applied to contracts entered into and performed entirely within Delaware by Delaware residents, without regard to the conflicts of laws principles. The United Nations Convention on Contracts for the International Sale of Goods is specifically disclaimed. You agree to all terms of this Agreement in the English language. The state or federal courts residing in Santa Clara County, California shall have exclusive jurisdiction over any dispute or claim arising out of this license. Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive remedies or an equivalent type of urgent legal relief in any jurisdiction. 
+
+12. NO ASSIGNMENT. This license and your rights and obligations thereunder may not be assigned by you by any means or operation of law without NVIDIA's permission. Any attempted assignment not approved by NVIDIA in writing shall be void and of no effect. 
+ 
+13. EXPORT. The SOFTWARE is subject to United States export laws and regulations. You agree that you will not ship, transfer or export the SOFTWARE into any country, or use the SOFTWARE in any manner, prohibited by the United States Bureau of Industry and Security or economic sanctions regulations administered by the U.S. Department of Treasury's Office of Foreign Assets Control (OFAC), or any applicable export laws, restrictions or regulations. These laws include restrictions on destinations, end users and end use. By accepting this license, you confirm that you are not a resident or citizen of any country currently embargoed by the U.S. and that you are not otherwise prohibited from receiving the SOFTWARE.
+
+14. GOVERNMENT USE. The SOFTWARE has been developed entirely at private expense and is "commercial items" consisting of "commercial computer software" and "commercial computer software documentation" provided with RESTRICTED RIGHTS. Use, duplication or disclosure by the U.S. Government or a U.S. Government subcontractor is subject to the restrictions in this license pursuant to DFARS 227.7202-3(a) or as set forth in subparagraphs (b)(1) and (2) of the Commercial Computer Software - Restricted Rights clause at FAR 52.227-19, as applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas Expressway, Santa Clara, CA 95051. 
+
+15. ENTIRE AGREEMENT. This license is the final, complete and exclusive agreement between the parties relating to the subject matter of this license and supersedes all prior or contemporaneous understandings and agreements relating to this subject matter, whether oral or written. If any court of competent jurisdiction determines that any provision of this license is illegal, invalid or unenforceable, the remaining provisions will remain in full force and effect. This license may only be modified in a writing signed by an authorized representative of each party.
+
+(v. May 12, 2021)
diff --git a/cuda/MANIFEST.in b/cuda/MANIFEST.in
new file mode 100644
index 00000000..ef9def92
--- /dev/null
+++ b/cuda/MANIFEST.in
@@ -0,0 +1,4 @@
+recursive-include cuda/ *.pyx *.pxd
+# at least with setuptools 75.0.0 this folder was added erroneously
+# to the payload, causing file copying to the build environment failed
+exclude cuda/bindings
diff --git a/cuda/README.md b/cuda/README.md
new file mode 100644
index 00000000..1cbafb56
--- /dev/null
+++ b/cuda/README.md
@@ -0,0 +1,76 @@
+# CUDA-Python
+
+CUDA Python is a standard set of low-level interfaces, providing full coverage of and access to the CUDA host APIs from Python. Checkout the [Overview](https://nvidia.github.io/cuda-python/overview.html) for the workflow and performance results.
+
+## Installing
+
+CUDA Python can be installed from:
+
+* PYPI
+* Conda (nvidia channel)
+* Source builds
+
+There're differences in each of these options that are described further in [Installation](https://nvidia.github.io/cuda-python/install.html) documentation. Each package will guarantee minor version compatibility.
+
+## Runtime Dependencies
+
+CUDA Python is supported on all platforms that CUDA is supported. Specific dependencies are as follows:
+
+* Driver: Linux (450.80.02 or later) Windows (456.38 or later)
+* CUDA Toolkit 12.0 to 12.6
+
+Only the NVRTC redistributable component is required from the CUDA Toolkit. [CUDA Toolkit Documentation](https://docs.nvidia.com/cuda/index.html) Installation Guides can be used for guidance. Note that the NVRTC component in the Toolkit can be obtained via PYPI, Conda or Local Installer.
+
+### Supported Python Versions
+
+CUDA Python follows [NEP 29](https://numpy.org/neps/nep-0029-deprecation_policy.html) for supported Python version guarantee.
+
+Before dropping support, an issue will be raised to look for feedback.
+
+Source builds work for multiple Python versions, however pre-build PyPI and Conda packages are only provided for a subset:
+
+* Python 3.9 to 3.12
+
+## Testing
+
+### Requirements
+
+Latest dependencies can be found in [requirements.txt](https://github.com/NVIDIA/cuda-python/blob/main/requirements.txt).
+
+### Unit-tests
+
+You can run the included tests with:
+
+```
+python -m pytest
+```
+
+### Benchmark
+
+You can run benchmark only tests with:
+
+```
+python -m pytest --benchmark-only
+```
+
+### Samples
+
+You can run the included tests with:
+
+```
+python -m pytest examples
+```
+
+## Examples
+
+CUDA Samples rewriten using CUDA Python are found in `examples`.
+
+Custom extra included examples:
+
+- `examples/extra/jit_program_test.py`: Demonstrates the use of the API to compile and
+  launch a kernel on the device. Includes device memory allocation /
+  deallocation, transfers between host and device, creation and usage of
+  streams, and context management.
+- `examples/extra/numba_emm_plugin.py`: Implements a Numba External Memory Management
+  plugin, showing that this CUDA Python Driver API can coexist with other
+  wrappers of the driver API.
diff --git a/cuda/_lib/ccudart/ccudart.pxd.in b/cuda/_lib/ccudart/ccudart.pxd.in
deleted file mode 100644
index 6d785138..00000000
--- a/cuda/_lib/ccudart/ccudart.pxd.in
+++ /dev/null
@@ -1,127 +0,0 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
-#
-# Please refer to the NVIDIA end user license agreement (EULA) associated
-# with this source code for terms and conditions that govern your use of
-# this software. Any use, reproduction, disclosure, or distribution of
-# this software and related documentation outside the terms of the EULA
-# is strictly prohibited.
-cimport cuda.ccuda as ccuda
-from cuda.ccudart cimport *
-from libc.stdlib cimport malloc, free, calloc
-from libc.string cimport memset, memcpy, strncmp
-from libcpp cimport bool
-
-{{if 'cudaMemcpy' in found_functions}}cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaStreamCreate' in found_functions}}cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaEventCreate' in found_functions}}cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaEventQuery' in found_functions}}cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaCreateChannelDesc' in found_functions}}cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil{{endif}}
-{{if 'cudaDriverGetVersion' in found_functions}}cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaRuntimeGetVersion' in found_functions}}cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMallocHost' in found_functions}}cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMallocPitch' in found_functions}}cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMallocMipmappedArray' in found_functions}}cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2D' in found_functions}}cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyAsync' in found_functions}}cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphAddMemcpyNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetDriverEntryPoint' in found_functions}}cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphAddMemsetNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaFuncGetAttributes' in found_functions}}cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMallocArray' in found_functions}}cdef cudaError_t _cudaMallocArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMalloc3D' in found_functions}}cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMalloc3DArray' in found_functions}}cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetErrorString' in found_functions}}cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil{{endif}}
-{{if 'cudaStreamAddCallback' in found_functions}}cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaStreamGetCaptureInfo' in found_functions}}cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}cdef cudaError_t _cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaImportExternalSemaphore' in found_functions}}cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaArrayGetInfo' in found_functions}}cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DToArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DFromArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DArrayToArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DToArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemset3D' in found_functions}}cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemset3DAsync' in found_functions}}cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyToArray' in found_functions}}cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyFromArray' in found_functions}}cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyToArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyFromArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaPointerGetAttributes' in found_functions}}cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetDeviceFlags' in found_functions}}cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy3D' in found_functions}}cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy3DAsync' in found_functions}}cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemPoolSetAccess' in found_functions}}cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceReset' in found_functions}}cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaThreadExit' in found_functions}}cdef cudaError_t _cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetLastError' in found_functions}}cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaPeekAtLastError' in found_functions}}cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetDevice' in found_functions}}cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaSetDevice' in found_functions}}cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetDeviceProperties' in found_functions}}cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaChooseDevice' in found_functions}}cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyArrayToArray' in found_functions}}cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetChannelDesc' in found_functions}}cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaCreateTextureObject' in found_functions}}cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaCreateTextureObject_v2' in found_functions}}cdef cudaError_t _cudaCreateTextureObject_v2(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc_v2* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}cdef cudaError_t _cudaGetTextureObjectTextureDesc_v2(cudaTextureDesc_v2* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetExportTable' in found_functions}}cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy3DPeer' in found_functions}}cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpy3DPeerAsync' in found_functions}}cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'make_cudaPitchedPtr' in found_functions}}cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil{{endif}}
-{{if 'make_cudaPos' in found_functions}}cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) nogil{{endif}}
-{{if 'make_cudaExtent' in found_functions}}cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) nogil{{endif}}
-{{if 'cudaSetDoubleForDevice' in found_functions}}cdef cudaError_t _cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaSetDoubleForHost' in found_functions}}cdef cudaError_t _cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaSetDeviceFlags' in found_functions}}cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphAddMemAllocNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemAdvise' in found_functions}}cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemRangeGetAttribute' in found_functions}}cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemRangeGetAttributes' in found_functions}}cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetDeviceCount' in found_functions}}cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceGetAttribute' in found_functions}}cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceGetByPCIBusId' in found_functions}}cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceGetPCIBusId' in found_functions}}cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceGetP2PAttribute' in found_functions}}cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaArrayGetSparseProperties' in found_functions}}cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceCanAccessPeer' in found_functions}}cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyPeer' in found_functions}}cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMemcpyPeerAsync' in found_functions}}cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceEnablePeerAccess' in found_functions}}cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaDeviceDisablePeerAccess' in found_functions}}cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphKernelNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaImportExternalMemory' in found_functions}}cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaCreateSurfaceObject' in found_functions}}cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-cdef cudaError_t _cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
-{{if 'cudaArrayGetMemoryRequirements' in found_functions}}cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaStreamGetAttribute' in found_functions}}cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaStreamSetAttribute' in found_functions}}cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
-{{if True}}cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
diff --git a/cuda/_lib/ccudart/ccudart.pyx.in b/cuda/_lib/ccudart/ccudart.pyx.in
deleted file mode 100644
index 1a96b254..00000000
--- a/cuda/_lib/ccudart/ccudart.pyx.in
+++ /dev/null
@@ -1,2473 +0,0 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
-#
-# Please refer to the NVIDIA end user license agreement (EULA) associated
-# with this source code for terms and conditions that govern your use of
-# this software. Any use, reproduction, disclosure, or distribution of
-# this software and related documentation outside the terms of the EULA
-# is strictly prohibited.
-from cuda.ccudart cimport *
-from cuda._lib.ccudart.utils cimport *
-from libc.stdlib cimport malloc, free, calloc
-from libc.string cimport memset, memcpy, strncmp
-from libcpp cimport bool
-cimport cuda._cuda.ccuda as ccuda
-
-cdef cudaPythonGlobal m_global = globalGetInstance()
-
-{{if 'cudaMemcpy' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyDispatch(dst, src, count, kind)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaStreamCreate' in found_functions}}
-
-cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamCreate(pStream, 0)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaEventCreate' in found_functions}}
-
-cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventCreate(event, ccuda.CUevent_flags_enum.CU_EVENT_DEFAULT)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaEventQuery' in found_functions}}
-
-cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuEventQuery(<ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaCreateChannelDesc' in found_functions}}
-
-cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) nogil:
-    cdef cudaChannelFormatDesc desc
-    desc.x = x
-    desc.y = y
-    desc.z = z
-    desc.w = w
-    desc.f = f
-    return desc
-
-
-{{endif}}
-{{if 'cudaDriverGetVersion' in found_functions}}
-
-cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuDriverGetVersion(driverVersion)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaRuntimeGetVersion' in found_functions}}
-
-cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    runtimeVersion[0] = m_global._CUDART_VERSION
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}
-
-cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if fmtDesc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    cdef ccuda.CUarray_format fmt
-    cdef int numChannels = 0
-
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    err = getDescInfo(fmtDesc, &numChannels, &fmt)
-    if err == cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmt, <unsigned>numChannels, device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMallocHost' in found_functions}}
-
-cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if ptr == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocHost(size, ptr, 0)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMallocPitch' in found_functions}}
-
-cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if devPtr == NULL or pitch == NULL:
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocPitch(width, height, 1, devPtr, pitch)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMallocMipmappedArray' in found_functions}}
-
-cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if mipmappedArray == NULL or desc == NULL:
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocMipmappedArray(mipmappedArray, desc, extent.depth, extent.height, extent.width, numLevels, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2D' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DPtr(<char*>dst, dpitch, <const char*>src, spitch, width, height, kind, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2DAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DPtr(<char*>dst, dpitch, <const char*>src, spitch, width, height, kind, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyAsyncDispatch(dst, src, count, kind, stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphAddMemcpyNode' in found_functions}}
-
-cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaError_t err
-
-    if pCopyParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = toDriverMemCopy3DParams(pCopyParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, &driverNodeParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}
-
-cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaMemcpy3DParms copyParams
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
-
-    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, &driverNodeParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}
-
-cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaMemcpy3DParms copyParams
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
-
-    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuGraphMemcpyNodeSetParams(node, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaError_t err
-
-    if pNodeParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = toDriverMemCopy3DParams(pNodeParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuGraphExecMemcpyNodeSetParams(hGraphExec, node, &driverNodeParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}
-
-cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaMemcpy3DParms copyParams
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
-
-    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuGraphExecMemcpyNodeSetParams(hGraphExec, node, &driverNodeParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGetDriverEntryPoint' in found_functions}}
-
-cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuGetProcAddress(symbol, funcPtr, m_global._CUDART_VERSION, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphAddMemsetNode' in found_functions}}
-
-cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS driverParams
-    cdef cudaError_t err
-
-    if pMemsetParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    toDriverMemsetNodeParams(pMemsetParams, &driverParams)
-
-    err = <cudaError_t>ccuda._cuGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, &driverParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUcontext context
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS driverParams
-    cdef cudaError_t err
-
-    if pNodeParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    toDriverMemsetNodeParams(pNodeParams, &driverParams)
-
-    err = <cudaError_t>ccuda._cuGraphExecMemsetNodeSetParams(hGraphExec, node, &driverParams, context)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-    cdef cudaError_t err
-
-    if pNodeParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = toDriverMemCopy3DParams(pNodeParams, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemcpyNodeSetParams(node, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUDA_MEMCPY3D_v2 driverNodeParams
-
-    if p == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemcpyNodeGetParams(node, &driverNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = toCudartMemCopy3DParams(&driverNodeParams, p)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaFuncGetAttributes' in found_functions}}
-
-cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if NULL == attr:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    cdef int bytes
-    memset(attr, 0, sizeof(cudaFuncAttributes))
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].maxThreadsPerBlock,     ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].numRegs,                ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NUM_REGS, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].ptxVersion,             ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PTX_VERSION, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].binaryVersion,          ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_BINARY_VERSION, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&bytes,                          ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    attr[0].sharedSizeBytes = <size_t>bytes
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&bytes,                          ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    attr[0].constSizeBytes = <size_t>bytes
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&bytes,                          ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    attr[0].localSizeBytes = <size_t>bytes
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].cacheModeCA,            ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CACHE_MODE_CA, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&bytes,                          ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuFuncGetAttribute(&attr[0].preferredShmemCarveout, ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT, <ccuda.CUfunction>func)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    attr[0].maxDynamicSharedSizeBytes = <size_t>bytes
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMallocArray' in found_functions}}
-
-cdef cudaError_t _cudaMallocArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if arrayPtr == NULL or desc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocArray(arrayPtr, desc, 0, height, width, 0, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMalloc3D' in found_functions}}
-
-cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if pitchedDevPtr == NULL:
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocPitch(extent.width, extent.height, extent.depth, &pitchedDevPtr[0].ptr, &pitchedDevPtr[0].pitch)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    pitchedDevPtr[0].xsize = extent.width
-    pitchedDevPtr[0].ysize = extent.height
-    return err
-
-
-{{endif}}
-{{if 'cudaMalloc3DArray' in found_functions}}
-
-cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if arrayPtr == NULL or desc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = mallocArray(arrayPtr, desc, extent.depth, extent.height, extent.width, 0, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGetErrorString' in found_functions}}
-
-cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil:
-    cdef const char* pStr = NULL
-    cdef cudaError_t err
-
-    err = <cudaError_t>ccuda._cuGetErrorString(<ccuda.CUresult>error, &pStr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    if err == <cudaError_t>cudaErrorInvalidValue:
-        pStr = "unrecognized error code"
-    return pStr
-
-
-{{endif}}
-{{if 'cudaStreamAddCallback' in found_functions}}
-
-cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = streamAddCallbackCommon(stream, callback, userData, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaStreamGetCaptureInfo' in found_functions}}
-
-cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = streamGetCaptureInfoCommon(stream, captureStatus_out, id_out, <cudaGraph_t *>0, <const cudaGraphNode_t **>0, <size_t *>0)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}
-
-cdef cudaError_t _cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = streamGetCaptureInfoCommon(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaImportExternalSemaphore' in found_functions}}
-
-cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC driverSemHandleDesc
-
-    if semHandleDesc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    memset(&driverSemHandleDesc, 0, sizeof(driverSemHandleDesc))
-
-    if semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD
-        driverSemHandleDesc.handle.fd = semHandleDesc.handle.fd
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC
-        driverSemHandleDesc.handle.nvSciSyncObj = semHandleDesc.handle.nvSciSyncObj
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD
-        driverSemHandleDesc.handle.fd = semHandleDesc.handle.fd
-    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32:
-        driverSemHandleDesc.type =  ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32
-        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
-        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
-    driverSemHandleDesc.flags = semHandleDesc.flags
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuImportExternalSemaphore(<ccuda.CUexternalSemaphore *>extSem_out, &driverSemHandleDesc)
-    if err != <cudaError_t>cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}
-
-cdef cudaError_t _cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuSignalExternalSemaphoresAsync(<const ccuda.CUexternalSemaphore *>extSemArray, <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *>paramsArray, numExtSems, stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}
-
-cdef cudaError_t _cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuWaitExternalSemaphoresAsync(<const ccuda.CUexternalSemaphore *>extSemArray, <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *>paramsArray, numExtSems, stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaArrayGetInfo' in found_functions}}
-
-cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 driverDesc
-    cdef size_t width  = 0
-    cdef size_t height = 0
-    cdef size_t depth  = 0
-
-    # Zero out parameters in case cuArray3DGetDescriptor fails
-    if flags:
-        flags[0] = 0
-
-    if desc:
-        memset(desc, 0, sizeof(desc[0]))
-
-
-    if extent:
-        memset(extent, 0, sizeof(extent[0]))
-
-    err = <cudaError_t>ccuda._cuArray3DGetDescriptor_v2(&driverDesc, <ccuda.CUarray>array)
-    if err != <cudaError_t>cudaSuccess:
-        _setLastError(err)
-        return err
-
-    # Flags are copied directly from the driver API
-    if flags:
-        flags[0] = driverDesc.Flags
-
-    # Convert from driver API types to runtime API types. extent.Depth = 0
-    # indicates a 2D array.
-    if desc:
-        width  = 0
-        height = 0
-        depth  = 0
-
-        err = getChannelFormatDescFromDriverDesc(desc, &depth, &height, &width, &driverDesc)
-        if err != <cudaError_t>cudaSuccess:
-            _setLastError(err)
-            return err
-
-    if extent:
-        extent.width  = driverDesc.Width
-        extent.height = driverDesc.Height
-        extent.depth  = driverDesc.Depth
-
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaMemcpy2DToArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DToArray(dst, hOffset, wOffset, <const char*>src, spitch, width, height, kind, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2DFromArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DFromArray(<char*>dst, dpitch, src, hOffset, wOffset, width, height, kind, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2DArrayToArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DArrayToArray(dst, hOffsetDst, wOffsetDst, src, hOffsetSrc, wOffsetSrc, width, height, kind)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2DToArrayAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DToArray(dst, hOffset, wOffset, <const char*>src, spitch, width, height, kind, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy2DFromArray(<char*>dst, dpitch, src, hOffset, wOffset, width, height, kind, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemset3D' in found_functions}}
-
-cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memset3DPtr(pitchedDevPtr, value, extent, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemset3DAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memset3DPtr(pitchedDevPtr, value, extent, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyToArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyToArray(dst, hOffset, wOffset, <const char*>src, count, kind, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyFromArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyFromArray(<char*>dst, src, hOffset, wOffset, count, kind, NULL, 0)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyToArrayAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyToArray(dst, hOffset, wOffset, <const char*>src, count, kind, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyFromArrayAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyFromArray(<char*>dst, src, hOffset, wOffset, count, kind, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaPointerGetAttributes' in found_functions}}
-
-cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef cudaPointerAttributes attrib
-    cdef ccuda.CUcontext driverContext = NULL
-    cdef ccuda.CUmemorytype driverMemoryType
-    cdef int isManaged
-    cdef ccuda.CUpointer_attribute[6] query
-    query[0] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT
-    query[1] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE
-    query[2] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER
-    query[3] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER
-    query[4] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED
-    query[5] = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
-
-    cdef void** data = [
-        &driverContext,
-        &driverMemoryType,
-        &attrib.devicePointer,
-        &attrib.hostPointer,
-        &isManaged,
-        &attrib.device
-    ]
-
-    if attributes == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    # Get all the attributes we need
-    err = <cudaError_t>ccuda._cuPointerGetAttributes(<unsigned int>(sizeof(query)/sizeof(query[0])), query, data, <ccuda.CUdeviceptr_v2>ptr)
-    if err != cudaSuccess:
-        if attributes != NULL:
-            memset(attributes, 0, sizeof(attributes[0]))
-            attributes[0].device = -1
-        _setLastError(err)
-        return err
-
-    if driverMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST:
-        if isManaged:
-            attrib.type = cudaMemoryTypeManaged
-        else:
-            attrib.type = cudaMemoryTypeHost
-    elif driverMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE:
-        if isManaged:
-            attrib.type = cudaMemoryTypeManaged
-        else:
-            attrib.type = cudaMemoryTypeDevice
-    else:
-         if driverMemoryType == 0:
-            attrib.type = cudaMemoryTypeUnregistered
-         else:
-            if attributes != NULL:
-                memset(attributes, 0, sizeof(attributes[0]))
-                attributes[0].device = -1
-            _setLastError(cudaErrorInvalidValue)
-            return cudaErrorInvalidValue
-
-    # copy to user structure
-    attributes[0] = attrib
-
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaGetDeviceFlags' in found_functions}}
-
-cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-
-    if flags == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef ccuda.CUcontext driverContext
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&driverContext)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    # Get the flags from the current context
-    if driverContext != NULL:
-        err = <cudaError_t>ccuda._cuCtxGetFlags(flags)
-        if err != cudaSuccess:
-            _setLastError(err)
-        return err
-
-    # Assume first valid device and get its implicit flags
-    cdef cudaPythonDevice* device
-    cdef unsigned int pcFlags
-    cdef int pcActive
-    device = m_global.getDevice(0)
-    err = <cudaError_t>ccuda._cuDevicePrimaryCtxGetState(device[0].driverDevice, &pcFlags, &pcActive)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    flags[0] = pcFlags | cudaDeviceMapHost
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaMemcpy3D' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if p == NULL:
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy3D(p, False, 0, 0, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy3DAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if p == NULL:
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpy3D(p, False, 0, 0, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemPoolSetAccess' in found_functions}}
-
-cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    cdef size_t MAX_DEVICES = 32
-    cdef ccuda.CUmemAccessDesc localList[32]
-    cdef ccuda.CUmemAccessDesc *cuDescList
-    cdef size_t i = 0
-
-    if (count > MAX_DEVICES):
-        cuDescList = <ccuda.CUmemAccessDesc*>calloc(sizeof(ccuda.CUmemAccessDesc), count)
-    else:
-        cuDescList = localList
-
-    if cuDescList == NULL:
-        _setLastError(cudaErrorMemoryAllocation)
-        return cudaErrorMemoryAllocation
-
-    while i < count:
-        cuDescList[i].location.type = <ccuda.CUmemLocationType>descList[i].location.type
-        cuDescList[i].location.id = descList[i].location.id
-        cuDescList[i].flags = <ccuda.CUmemAccess_flags>descList[i].flags
-        i += 1
-
-    err = <cudaError_t>ccuda._cuMemPoolSetAccess(memPool, cuDescList, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    if count > MAX_DEVICES:
-        free(cuDescList)
-
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaDeviceReset' in found_functions}}
-
-cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef int deviceOrdinal = 0
-    cdef cudaError_t err
-    if not m_global._lazyInitDriver:
-        return cudaSuccess
-
-    cdef ccuda.CUcontext context
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    cdef cudaPythonDevice* device
-    device = m_global.getDeviceFromPrimaryCtx(context)
-    if device != NULL:
-        err = resetPrimaryContext(device)
-        if err != cudaSuccess:
-            _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaThreadExit' in found_functions}}
-
-cdef cudaError_t _cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil:
-    return cudaDeviceReset()
-
-
-{{endif}}
-{{if 'cudaGetLastError' in found_functions}}
-
-cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t last_err = m_global._lastError
-    m_global._lastError = cudaSuccess
-    return last_err
-
-
-{{endif}}
-{{if 'cudaPeekAtLastError' in found_functions}}
-
-cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
-    return m_global._lastError
-
-
-{{endif}}
-{{if 'cudaGetDevice' in found_functions}}
-
-cdef cudaError_t _cudaGetDevice(int* deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUdevice driverDevice
-
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-
-    cdef cudaPythonDevice *cudaDevice
-    err = <cudaError_t>ccuda._cuCtxGetDevice(&driverDevice)
-    if err == cudaSuccess:
-        cudaDevice = m_global.getDeviceFromDriver(driverDevice)
-        deviceOrdinal[0] = cudaDevice[0].deviceOrdinal
-    elif err == cudaErrorDeviceUninitialized:
-        # Like C Runtime, default to first device and let context creation happen in another call
-        # By default, device 0 would initialized
-        deviceOrdinal[0] = 0
-        err = cudaSuccess
-    return err
-
-
-{{endif}}
-{{if 'cudaSetDevice' in found_functions}}
-
-cdef cudaError_t _cudaSetDevice(int deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef cudaPythonDevice *device
-
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-
-    device = m_global.getDevice(deviceOrdinal)
-    if device == NULL:
-        _setLastError(err)
-        return cudaErrorInvalidDevice
-
-    if device.primaryContext == NULL:
-        initPrimaryContext(device)
-
-    err = <cudaError_t>ccuda._cuCtxSetCurrent(device.primaryContext)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGetDeviceProperties' in found_functions}}
-
-cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-
-    device = m_global.getDevice(deviceOrdinal)
-    if device == NULL:
-        _setLastError(err)
-        return cudaErrorInvalidDevice
-
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.kernelExecTimeoutEnabled),  ccuda.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, device[0].driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.computeMode),  ccuda.CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, device[0].driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.clockRate), ccuda.CU_DEVICE_ATTRIBUTE_CLOCK_RATE, device[0].driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryClockRate), ccuda.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, device[0].driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.singleToDoublePrecisionPerfRatio), ccuda.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO, device[0].driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    prop[0] = device[0].deviceProperties
-
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaChooseDevice' in found_functions}}
-
-cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if device == NULL or prop == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    cdef int best = -1
-    cdef int maxrank = -1
-    cdef int rank
-    cdef char* dontCare_name = [b'\0']
-    cdef int dontCare_major = -1
-    cdef int dontCare_minor = -1
-    cdef size_t dontCare_totalGlobalMem = 0
-    cdef int deviceOrdinal = 0
-    cdef cudaDeviceProp *devProp
-
-    for deviceOrdinal in range(m_global._numDevices):
-        devProp = &m_global._deviceList[deviceOrdinal].deviceProperties
-        rank = 0
-        if (strncmp(prop[0].name, dontCare_name, sizeof(prop[0].name)) != 0):
-            rank += strncmp(prop[0].name, devProp[0].name, sizeof(prop[0].name)) == 0
-        if (prop[0].major != dontCare_major):
-            rank += prop[0].major <= devProp[0].major
-        if (prop[0].major == devProp[0].major and prop[0].minor != dontCare_minor):
-            rank += prop[0].minor <= devProp[0].minor
-        if (prop[0].totalGlobalMem != dontCare_totalGlobalMem):
-            rank += prop[0].totalGlobalMem <= devProp[0].totalGlobalMem
-        if (rank > maxrank):
-            maxrank = rank
-            best = deviceOrdinal
-
-    device[0] = best
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaMemcpyArrayToArray' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = memcpyArrayToArray(dst, hOffsetDst, wOffsetDst, src, hOffsetSrc, wOffsetSrc, count, kind)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGetChannelDesc' in found_functions}}
-
-cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    if desc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = getChannelDesc(array, desc)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaCreateTextureObject' in found_functions}}
-
-cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    if pResDesc == NULL or pTexDesc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef ccuda.CUDA_RESOURCE_DESC rd
-    cdef ccuda.CUDA_TEXTURE_DESC td
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC rvd
-    cdef cudaTextureDesc_v2 texDesc
-    memcpy(&texDesc, pTexDesc, sizeof(cudaTextureDesc))
-    texDesc.seamlessCubemap = 0
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if pResViewDesc:
-        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, &texDesc, &rvd, pResViewDesc)
-    else:
-        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, &texDesc, NULL, pResViewDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    if pResViewDesc:
-        err = <cudaError_t>ccuda._cuTexObjectCreate(pTexObject, &rd, &td, &rvd)
-    else:
-        err = <cudaError_t>ccuda._cuTexObjectCreate(pTexObject, &rd, &td, NULL)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaCreateTextureObject_v2' in found_functions}}
-
-cdef cudaError_t _cudaCreateTextureObject_v2(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc_v2* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    if pResDesc == NULL or pTexDesc == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef ccuda.CUDA_RESOURCE_DESC rd
-    cdef ccuda.CUDA_TEXTURE_DESC td
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC rvd
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if pResViewDesc:
-        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, pTexDesc, &rvd, pResViewDesc)
-    else:
-        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, pTexDesc, NULL, pResViewDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    if pResViewDesc:
-        err = <cudaError_t>ccuda._cuTexObjectCreate(pTexObject, &rd, &td, &rvd)
-    else:
-        err = <cudaError_t>ccuda._cuTexObjectCreate(pTexObject, &rd, &td, NULL)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}
-
-cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    cdef cudaResourceDesc resDesc
-    cdef ccuda.CUDA_RESOURCE_DESC rd
-    cdef ccuda.CUDA_TEXTURE_DESC td
-    cdef cudaTextureDesc_v2 texDesc
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuTexObjectGetResourceDesc(&rd, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuTexObjectGetTextureDesc(&td, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = getResDescFromDriverResDesc(&resDesc, &rd, &texDesc, &td, NULL, NULL)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    memcpy(pTexDesc, &texDesc, sizeof(cudaTextureDesc))
-
-    return cudaSuccess
-
-{{endif}}
-{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}
-
-cdef cudaError_t _cudaGetTextureObjectTextureDesc_v2(cudaTextureDesc_v2* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    cdef cudaResourceDesc resDesc
-    cdef ccuda.CUDA_RESOURCE_DESC rd
-    cdef ccuda.CUDA_TEXTURE_DESC td
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuTexObjectGetResourceDesc(&rd, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuTexObjectGetTextureDesc(&td, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = getResDescFromDriverResDesc(&resDesc, &rd, pTexDesc, &td, NULL, NULL)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    return cudaSuccess
-
-{{endif}}
-{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}
-
-cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef cudaResourceDesc resDesc
-    cdef ccuda.CUDA_RESOURCE_DESC rd
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC rvd
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err =  <cudaError_t>ccuda.cuTexObjectGetResourceDesc(&rd, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err =  <cudaError_t>ccuda.cuTexObjectGetResourceViewDesc(&rvd, texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = getResDescFromDriverResDesc(&resDesc, &rd, NULL, NULL, pResViewDesc, &rvd)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaGetExportTable' in found_functions}}
-
-cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGetExportTable(ppExportTable, <ccuda.CUuuid*>pExportTableId)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpy3DPeer' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if p == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    cdef cudaMemcpy3DParms cp
-    memset(&cp, 0, sizeof(cp))
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cp.srcArray = p[0].srcArray
-    cp.srcPos = p[0].srcPos
-    cp.srcPtr = p[0].srcPtr
-    cp.dstArray = p[0].dstArray
-    cp.dstPos = p[0].dstPos
-    cp.dstPtr = p[0].dstPtr
-    cp.extent = p[0].extent
-    cp.kind = cudaMemcpyKind.cudaMemcpyDeviceToDevice
-
-    err = memcpy3D(&cp, True, p[0].srcDevice, p[0].dstDevice, NULL, False)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaMemcpy3DPeerAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if p == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    cdef cudaError_t err
-    cdef cudaMemcpy3DParms cp
-    memset(&cp, 0, sizeof(cp))
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cp.srcArray = p[0].srcArray
-    cp.srcPos = p[0].srcPos
-    cp.srcPtr = p[0].srcPtr
-    cp.dstArray = p[0].dstArray
-    cp.dstPos = p[0].dstPos
-    cp.dstPtr = p[0].dstPtr
-    cp.extent = p[0].extent
-    cp.kind = cudaMemcpyKind.cudaMemcpyDeviceToDevice
-
-    err = memcpy3D(&cp, True, p[0].srcDevice, p[0].dstDevice, stream, True)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'make_cudaPitchedPtr' in found_functions}}
-
-cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) nogil:
-    cdef cudaPitchedPtr s
-    s.ptr   = d
-    s.pitch = p
-    s.xsize = xsz
-    s.ysize = ysz
-    return s
-
-
-{{endif}}
-{{if 'make_cudaPos' in found_functions}}
-
-cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) nogil:
-    cdef cudaPos p
-    p.x = x
-    p.y = y
-    p.z = z
-    return p
-
-
-{{endif}}
-{{if 'make_cudaExtent' in found_functions}}
-
-cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) nogil:
-    cdef cudaExtent e
-    e.width  = w
-    e.height = h
-    e.depth  = d
-    return e
-
-
-{{endif}}
-{{if 'cudaSetDoubleForDevice' in found_functions}}
-
-cdef cudaError_t _cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaSetDoubleForHost' in found_functions}}
-
-cdef cudaError_t _cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaSetDeviceFlags' in found_functions}}
-
-cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    flags &= ~cudaDeviceMapHost
-    if flags & ~cudaDeviceMask:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    cdef unsigned int scheduleFlags = flags & cudaDeviceScheduleMask
-    if scheduleFlags and (scheduleFlags != cudaDeviceScheduleSpin and
-                          scheduleFlags != cudaDeviceScheduleYield and
-                          scheduleFlags != cudaDeviceScheduleBlockingSync):
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-
-    cdef ccuda.CUcontext context
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    cdef cudaPythonDevice* device
-    device = m_global.getDeviceFromPrimaryCtx(context)
-    if device == NULL:
-        # We don't know if context provided is primary or not
-        # cudaSetDevice may need to be called before retrying call
-        return cudaErrorIncompatibleDriverContext
-
-    err = <cudaError_t>ccuda._cuDevicePrimaryCtxSetFlags_v2(device[0].driverDevice, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphAddMemAllocNode' in found_functions}}
-
-cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    if nodeParams == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-    
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, <ccuda.CUDA_MEM_ALLOC_NODE_PARAMS *>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    if params_out == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemAllocNodeGetParams(node, <ccuda.CUDA_MEM_ALLOC_NODE_PARAMS *>params_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    if dptr_out == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemFreeNodeGetParams(node, <ccuda.CUdeviceptr *>dptr_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemAdvise' in found_functions}}
-
-cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuMemAdvise(<ccuda.CUdeviceptr>devPtr, count, <ccuda.CUmem_advise>advice, <ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemRangeGetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuMemRangeGetAttribute(data, dataSize, <ccuda.CUmem_range_attribute>attribute, <ccuda.CUdeviceptr>devPtr, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMemRangeGetAttributes' in found_functions}}
-
-cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuMemRangeGetAttributes(data, dataSizes, <ccuda.CUmem_range_attribute*>attributes, numAttributes, <ccuda.CUdeviceptr>devPtr, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaGetDeviceCount' in found_functions}}
-
-cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    count[0] = m_global._numDevices
-    return cudaSuccess
-
-
-{{endif}}
-{{if 'cudaDeviceGetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuDeviceGetAttribute(value, <ccuda.CUdevice_attribute>attr, <ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
-
-cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSetSharedMemConfig(<ccuda.CUsharedconfig>config)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceGetByPCIBusId' in found_functions}}
-
-cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuDeviceGetByPCIBusId(<ccuda.CUdevice*>device, pciBusId)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceGetPCIBusId' in found_functions}}
-
-cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuDeviceGetPCIBusId(pciBusId, length, <ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceGetP2PAttribute' in found_functions}}
-
-cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuDeviceGetP2PAttribute(value, <ccuda.CUdevice_P2PAttribute>attr, <ccuda.CUdevice>srcDevice, <ccuda.CUdevice>dstDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaArrayGetSparseProperties' in found_functions}}
-
-cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_ARRAY_SPARSE_PROPERTIES _driver_sparseProperties
-    if not sparseProperties:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaError.cudaErrorInvalidValue
-    memset(sparseProperties, 0, sizeof(cudaArraySparseProperties))
-
-    err = <cudaError_t>ccuda._cuArrayGetSparseProperties(&_driver_sparseProperties, <ccuda.CUarray>array)
-    if err == cudaSuccess:
-        sparseProperties[0].miptailFirstLevel = _driver_sparseProperties.miptailFirstLevel
-        sparseProperties[0].miptailSize       = _driver_sparseProperties.miptailSize
-        sparseProperties[0].flags             = _driver_sparseProperties.flags
-        sparseProperties[0].tileExtent.width  = _driver_sparseProperties.tileExtent.width
-        sparseProperties[0].tileExtent.height = _driver_sparseProperties.tileExtent.height
-        sparseProperties[0].tileExtent.depth  = _driver_sparseProperties.tileExtent.depth
-
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}
-
-cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_ARRAY_SPARSE_PROPERTIES _driver_sparseProperties
-    if not sparseProperties:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaError.cudaErrorInvalidValue
-    memset(sparseProperties, 0, sizeof(cudaArraySparseProperties))
-
-    err = <cudaError_t>ccuda._cuMipmappedArrayGetSparseProperties(&_driver_sparseProperties, <ccuda.CUmipmappedArray>mipmap)
-    if err == cudaSuccess:
-        sparseProperties[0].miptailFirstLevel = _driver_sparseProperties.miptailFirstLevel
-        sparseProperties[0].miptailSize       = _driver_sparseProperties.miptailSize
-        sparseProperties[0].flags             = _driver_sparseProperties.flags
-        sparseProperties[0].tileExtent.width  = _driver_sparseProperties.tileExtent.width
-        sparseProperties[0].tileExtent.height = _driver_sparseProperties.tileExtent.height
-        sparseProperties[0].tileExtent.depth  = _driver_sparseProperties.tileExtent.depth
-
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceCanAccessPeer' in found_functions}}
-
-cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitDriver()
-    if err != cudaSuccess:
-        return err
-    cdef cudaPythonDevice *driverDevice
-    cdef cudaPythonDevice *driverPeerDevice
-    driverDevice = m_global.getDevice(device)
-    driverPeerDevice = m_global.getDevice(peerDevice)
-    if driverDevice == NULL or driverPeerDevice == NULL:
-        return cudaErrorInvalidDevice
-
-    err = <cudaError_t>ccuda._cuDeviceCanAccessPeer(canAccessPeer, driverDevice.driverDevice, driverPeerDevice.driverDevice)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    if device == peerDevice:
-        canAccessPeer[0] = 0
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyPeer' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef cudaPythonDevice *device
-    cdef cudaPythonDevice *peerDevice
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if count > 0:
-        peerDevice = m_global.getDevice(dstDevice)
-        device = m_global.getDevice(srcDevice)
-        if device == NULL or peerDevice == NULL:
-            _setLastError(err)
-            return cudaErrorInvalidDevice
-        err = initPrimaryContext(peerDevice)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-        err = initPrimaryContext(device)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-        err = <cudaError_t>ccuda._cuMemcpyPeer(<ccuda.CUdeviceptr>dst, peerDevice[0].primaryContext, <ccuda.CUdeviceptr>src, device[0].primaryContext, count)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-    return err
-
-
-{{endif}}
-{{if 'cudaMemcpyPeerAsync' in found_functions}}
-
-cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef cudaPythonDevice *device
-    cdef cudaPythonDevice *peerDevice
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if count > 0:
-        peerDevice = m_global.getDevice(dstDevice)
-        device = m_global.getDevice(srcDevice)
-        if device == NULL or peerDevice == NULL:
-            _setLastError(err)
-            return cudaErrorInvalidDevice
-        err = initPrimaryContext(peerDevice)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-        err = initPrimaryContext(device)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-        err = <cudaError_t>ccuda._cuMemcpyPeerAsync(<ccuda.CUdeviceptr>dst, peerDevice[0].primaryContext, <ccuda.CUdeviceptr>src, device[0].primaryContext, count, <ccuda.CUstream>stream)
-        if err != cudaSuccess:
-            _setLastError(err)
-            return err
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceEnablePeerAccess' in found_functions}}
-
-cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUcontext context
-    cdef cudaPythonDevice *dev
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    dev = m_global.getDeviceFromPrimaryCtx(context)
-    if dev == NULL:
-        # We don't know if context provided is primary or not
-        # cudaSetDevice may need to be called before retrying call
-        _setLastError(cudaErrorIncompatibleDriverContext)
-        return cudaErrorIncompatibleDriverContext
-    dev = m_global.getDevice(peerDevice)
-    if dev == NULL:
-        return cudaErrorInvalidDevice
-    err = initPrimaryContext(dev)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuCtxEnablePeerAccess(dev.primaryContext, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-
-{{endif}}
-{{if 'cudaDeviceDisablePeerAccess' in found_functions}}
-
-cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUcontext context
-    cdef cudaPythonDevice *dev
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetCurrent(&context)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    dev = m_global.getDeviceFromPrimaryCtx(context)
-    if dev == NULL:
-        # We don't know if context provided is primary or not
-        # cudaSetDevice may need to be called before retrying call
-        _setLastError(cudaErrorIncompatibleDriverContext)
-        return cudaErrorIncompatibleDriverContext
-    dev = m_global.getDevice(peerDevice)
-    if dev == NULL:
-        return cudaErrorInvalidDevice
-    err = initPrimaryContext(dev)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuCtxDisablePeerAccess(dev.primaryContext)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}
-
-cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC _driver_mipmapDesc
-    memset(&_driver_mipmapDesc, 0, sizeof(_driver_mipmapDesc))
-    _driver_mipmapDesc.offset = mipmapDesc[0].offset
-    _driver_mipmapDesc.arrayDesc.Width = mipmapDesc[0].extent.width
-    _driver_mipmapDesc.arrayDesc.Height = mipmapDesc[0].extent.height
-    _driver_mipmapDesc.arrayDesc.Depth = mipmapDesc[0].extent.depth
-    err_rt = getDescInfo(&mipmapDesc[0].formatDesc, <int *>&_driver_mipmapDesc.arrayDesc.NumChannels, &_driver_mipmapDesc.arrayDesc.Format)
-    if err_rt != cudaError.cudaSuccess:
-        _setLastError(err_rt)
-        return err_rt
-    _driver_mipmapDesc.arrayDesc.Flags = mipmapDesc[0].flags
-    _driver_mipmapDesc.numLevels = mipmapDesc[0].numLevels
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuExternalMemoryGetMappedMipmappedArray(<ccuda.CUmipmappedArray*>mipmap, <ccuda.CUexternalMemory>extMem, &_driver_mipmapDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}
-
-cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_RESOURCE_DESC _driver_pResDesc
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuSurfObjectGetResourceDesc(&_driver_pResDesc, <ccuda.CUsurfObject>surfObject)
-    memset(pResDesc, 0, sizeof(cudaResourceDesc))
-    if _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_ARRAY:
-        pResDesc[0].resType         = cudaResourceType.cudaResourceTypeArray
-        pResDesc[0].res.array.array = <cudaArray_t>_driver_pResDesc.res.array.hArray
-    elif _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY:
-        pResDesc[0].resType = cudaResourceType.cudaResourceTypeMipmappedArray
-        pResDesc[0].res.mipmap.mipmap = <cudaMipmappedArray_t>_driver_pResDesc.res.mipmap.hMipmappedArray
-    elif _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_LINEAR:
-        pResDesc[0].resType                = cudaResourceType.cudaResourceTypeLinear
-        pResDesc[0].res.linear.devPtr      = <void *>_driver_pResDesc.res.linear.devPtr
-        pResDesc[0].res.linear.sizeInBytes = _driver_pResDesc.res.linear.sizeInBytes
-    elif _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_PITCH2D:
-        pResDesc[0].resType                  = cudaResourceType.cudaResourceTypePitch2D
-        pResDesc[0].res.pitch2D.devPtr       = <void *>_driver_pResDesc.res.pitch2D.devPtr
-        pResDesc[0].res.pitch2D.pitchInBytes = _driver_pResDesc.res.pitch2D.pitchInBytes
-        pResDesc[0].res.pitch2D.width        = _driver_pResDesc.res.pitch2D.width
-        pResDesc[0].res.pitch2D.height       = _driver_pResDesc.res.pitch2D.height
-    if _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_LINEAR or _driver_pResDesc.resType == ccuda.CU_RESOURCE_TYPE_PITCH2D:
-        channel_size = 0
-        if _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_UNSIGNED_INT8:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
-            channel_size = 8
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_UNSIGNED_INT16:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
-            channel_size = 16
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_UNSIGNED_INT32:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
-            channel_size = 32
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_SIGNED_INT8:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
-            channel_size = 8
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_SIGNED_INT16:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
-            channel_size = 16
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_SIGNED_INT32:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
-            channel_size = 32
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_HALF:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindFloat
-            channel_size = 16
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_FLOAT:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindFloat
-            channel_size = 32
-        elif _driver_pResDesc.res.linear.format == ccuda.CU_AD_FORMAT_NV12:
-            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindNV12
-            channel_size = 8
-        else:
-            _setLastError(cudaErrorInvalidChannelDescriptor)
-            return cudaError.cudaErrorInvalidChannelDescriptor
-        pResDesc[0].res.linear.desc.x = 0
-        pResDesc[0].res.linear.desc.y = 0
-        pResDesc[0].res.linear.desc.z = 0
-        pResDesc[0].res.linear.desc.w = 0
-        if _driver_pResDesc.res.linear.numChannels >= 4:
-            pResDesc[0].res.linear.desc.w = channel_size
-        if _driver_pResDesc.res.linear.numChannels >= 3:
-            pResDesc[0].res.linear.desc.z = channel_size
-        if _driver_pResDesc.res.linear.numChannels >= 2:
-            pResDesc[0].res.linear.desc.y = channel_size
-        if _driver_pResDesc.res.linear.numChannels >= 1:
-            pResDesc[0].res.linear.desc.x = channel_size
-        if _driver_pResDesc.res.linear.numChannels < 1 or _driver_pResDesc.res.linear.numChannels >= 5:
-            _setLastError(cudaErrorInvalidChannelDescriptor)
-            return cudaError.cudaErrorInvalidChannelDescriptor
-
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGraphKernelNodeGetParams' in found_functions}}
-
-cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphKernelNodeGetParams(<ccuda.CUgraphNode>node, &_driver_pNodeParams)
-    pNodeParams[0].func = <void*>_driver_pNodeParams.func
-    pNodeParams[0].gridDim.x = _driver_pNodeParams.gridDimX
-    pNodeParams[0].gridDim.y = _driver_pNodeParams.gridDimY
-    pNodeParams[0].gridDim.z = _driver_pNodeParams.gridDimZ
-    pNodeParams[0].blockDim.x = _driver_pNodeParams.blockDimX
-    pNodeParams[0].blockDim.y = _driver_pNodeParams.blockDimY
-    pNodeParams[0].blockDim.z = _driver_pNodeParams.blockDimZ
-    pNodeParams[0].sharedMemBytes = _driver_pNodeParams.sharedMemBytes
-    pNodeParams[0].kernelParams = _driver_pNodeParams.kernelParams
-    pNodeParams[0].extra = _driver_pNodeParams.extra
-
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}
-
-cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC _driver_bufferDesc
-    memset(&_driver_bufferDesc, 0, sizeof(_driver_bufferDesc))
-    _driver_bufferDesc.offset = bufferDesc[0].offset
-    _driver_bufferDesc.size = bufferDesc[0].size
-    _driver_bufferDesc.flags = bufferDesc[0].flags
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuExternalMemoryGetMappedBuffer(<ccuda.CUdeviceptr*>devPtr, <ccuda.CUexternalMemory>extMem, &_driver_bufferDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaImportExternalMemory' in found_functions}}
-
-cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC _driver_memHandleDesc
-    memset(&_driver_memHandleDesc, 0, sizeof(_driver_memHandleDesc))
-
-    if memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD
-        _driver_memHandleDesc.handle.fd = memHandleDesc[0].handle.fd
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
-        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
-        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
-    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf:
-        _driver_memHandleDesc.type = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF
-        _driver_memHandleDesc.handle.nvSciBufObject = memHandleDesc[0].handle.nvSciBufObject
-    _driver_memHandleDesc.size = memHandleDesc[0].size
-    _driver_memHandleDesc.flags = memHandleDesc[0].flags
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuImportExternalMemory(<ccuda.CUexternalMemory*>extMem_out, &_driver_memHandleDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaCreateSurfaceObject' in found_functions}}
-
-cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cdef ccuda.CUDA_RESOURCE_DESC _driver_pResDesc
-    memset(&_driver_pResDesc, 0, sizeof(_driver_pResDesc))
-    err = toDriverCudaResourceDesc(&_driver_pResDesc, pResDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuSurfObjectCreate(<ccuda.CUsurfObject*>pSurfObject, &_driver_pResDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}
-
-cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cdef ccuda.CUDA_RESOURCE_DESC _driver_pResDesc
-    memset(&_driver_pResDesc, 0, sizeof(_driver_pResDesc))
-    err = toDriverCudaResourceDesc(&_driver_pResDesc, pResDesc)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    err = <cudaError_t>ccuda._cuTexObjectGetResourceDesc(&_driver_pResDesc, <ccuda.CUtexObject>texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-cdef cudaError_t _cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuProfilerInitialize(configFile, outputFile, <ccuda.CUoutput_mode>outputMode)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cdef ccuda.CUeglFrame cueglFrame
-    err = getDriverEglFrame(&cueglFrame, eglframe)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamProducerPresentFrame(<ccuda.CUeglStreamConnection*>conn, cueglFrame, pStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    if eglframe == NULL:
-        err = cudaErrorInvalidResourceHandle
-        _setLastError(err)
-        return err
-    cdef ccuda.CUeglFrame cueglFrame
-    err = <cudaError_t>ccuda._cuEGLStreamProducerReturnFrame(<ccuda.CUeglStreamConnection*>conn, &cueglFrame, pStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = getRuntimeEglFrame(eglframe, cueglFrame)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    return err
-
-cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    cdef ccuda.CUeglFrame cueglFrame
-    memset(&cueglFrame, 0, sizeof(cueglFrame))
-    err = <cudaError_t>ccuda._cuGraphicsResourceGetMappedEglFrame(&cueglFrame, <ccuda.CUgraphicsResource>resource, index, mipLevel)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    err = getRuntimeEglFrame(eglFrame, cueglFrame)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-    return err
-
-cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return cudaErrorNotSupported
-
-{{if 'cudaArrayGetMemoryRequirements' in found_functions}}
-
-cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS driverMemoryRequirements
-    if memoryRequirements == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    memset(memoryRequirements, 0, sizeof(memoryRequirements[0]))
-    err = <cudaError_t>ccuda._cuArrayGetMemoryRequirements(&driverMemoryRequirements, <ccuda.CUarray>array, device)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    memoryRequirements[0].size = driverMemoryRequirements.size
-    memoryRequirements[0].alignment = driverMemoryRequirements.alignment
-    return cudaSuccess
-
-{{endif}}
-{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}
-
-cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    cdef ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS driverMemoryRequirements
-    if memoryRequirements == NULL:
-        _setLastError(cudaErrorInvalidValue)
-        return cudaErrorInvalidValue
-
-    memset(memoryRequirements, 0, sizeof(memoryRequirements[0]))
-    err = <cudaError_t>ccuda._cuMipmappedArrayGetMemoryRequirements(&driverMemoryRequirements, <ccuda.CUmipmappedArray>mipmap, device)
-    if err != cudaSuccess:
-        _setLastError(err)
-        return err
-
-    memoryRequirements[0].size = driverMemoryRequirements.size
-    memoryRequirements[0].alignment = driverMemoryRequirements.alignment
-    return cudaSuccess
-
-{{endif}}
-{{if 'cudaStreamGetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamGetAttribute(<ccuda.CUstream>hStream, <ccuda.CUstreamAttrID>attr, <ccuda.CUstreamAttrValue*>value_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaStreamSetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamSetAttribute(<ccuda.CUstream>hStream, <ccuda.CUstreamAttrID>attr, <ccuda.CUstreamAttrValue*>value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphKernelNodeGetAttribute(<ccuda.CUgraphNode>hNode, <ccuda.CUkernelNodeAttrID>attr, <ccuda.CUkernelNodeAttrValue*>value_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}
-
-cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphKernelNodeSetAttribute(<ccuda.CUgraphNode>hNode, <ccuda.CUkernelNodeAttrID>attr, <ccuda.CUkernelNodeAttrValue*>value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-{{if True}}
-
-{{if 'Windows' != platform.system()}}
-cimport cuda._lib.dlfcn as dlfcn
-{{endif}}
-
-cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
-    {{if 'Windows' == platform.system()}}
-    with gil:
-        raise NotImplementedError('"getLocalRuntimeVersion" is unsupported on Windows')
-    {{else}}
-    # Load
-    handle = dlfcn.dlopen('libcudart.so.12', dlfcn.RTLD_NOW)
-    if handle == NULL:
-        with gil:
-            raise RuntimeError(f'Failed to dlopen libcudart.so.12')
-
-    __cudaRuntimeGetVersion = dlfcn.dlsym(handle, 'cudaRuntimeGetVersion')
-
-    if __cudaRuntimeGetVersion == NULL:
-        with gil:
-            raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in libcudart.so.12')
-
-    # Call
-    cdef cudaError_t err = cudaSuccess
-    err = (<cudaError_t (*)(int*) nogil> __cudaRuntimeGetVersion)(runtimeVersion)
-
-    # Unload
-    dlfcn.dlclose(handle)
-
-    # Return
-    return err
-    {{endif}}
-{{endif}}
\ No newline at end of file
diff --git a/cuda/__init__.pxd b/cuda/cuda/__init__.pxd
similarity index 100%
rename from cuda/__init__.pxd
rename to cuda/cuda/__init__.pxd
diff --git a/cuda/cuda/__init__.py b/cuda/cuda/__init__.py
new file mode 100644
index 00000000..8b302752
--- /dev/null
+++ b/cuda/cuda/__init__.py
@@ -0,0 +1,10 @@
+def __getattr__(name):
+    if name == "__version__":
+        import warnings
+        warnings.warn("accessing cuda.__version__ is deprecated, "
+                      "please switch to use cuda.bindings.__version__ instead",
+                      DeprecationWarning, stacklevel=2)
+        from . import bindings
+        return bindings.__version__
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/cuda/_cuda/__init__.py b/cuda/cuda/bindings/__init__.pxd
similarity index 100%
rename from cuda/_cuda/__init__.py
rename to cuda/cuda/bindings/__init__.pxd
diff --git a/cuda/__init__.py b/cuda/cuda/bindings/__init__.py
similarity index 100%
rename from cuda/__init__.py
rename to cuda/cuda/bindings/__init__.py
diff --git a/cuda/_lib/__init__.py b/cuda/cuda/bindings/_bindings/__init__.py
similarity index 100%
rename from cuda/_lib/__init__.py
rename to cuda/cuda/bindings/_bindings/__init__.py
diff --git a/cuda/_cuda/ccuda.pxd.in b/cuda/cuda/bindings/_bindings/cydriver.pxd.in
similarity index 98%
rename from cuda/_cuda/ccuda.pxd.in
rename to cuda/cuda/bindings/_bindings/cydriver.pxd.in
index 77d84b92..89f67b3d 100644
--- a/cuda/_cuda/ccuda.pxd.in
+++ b/cuda/cuda/bindings/_bindings/cydriver.pxd.in
@@ -1,11 +1,11 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-from cuda.ccuda cimport *
+from cuda.bindings.cydriver cimport *
 
 {{if 'cuGetErrorString' in found_functions}}
 
@@ -1862,97 +1862,98 @@ cdef CUresult _cuProfilerStart() except ?CUDA_ERROR_NOT_FOUND nogil
 cdef CUresult _cuProfilerStop() except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuVDPAUGetDevice' in found_functions}}
-
-cdef CUresult _cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-
-cdef CUresult _cuVDPAUCtxCreate_v2(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-cdef CUresult _cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-cdef CUresult _cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGLImageKHR image, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn, EGLStreamKHR stream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgraphicsResource* pCudaResource, CUstream* pStream, unsigned int timeout) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgraphicsResource pCudaResource, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream, EGLint width, EGLint height) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraphicsResource resource, unsigned int index, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGLGetDevices_v2' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGLGetDevices_v2(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
+
+{{if True}}
+
+cdef CUresult _cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuVDPAUCtxCreate_v2(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
+
diff --git a/cuda/_cuda/ccuda.pyx.in b/cuda/cuda/bindings/_bindings/cydriver.pyx.in
similarity index 91%
rename from cuda/_cuda/ccuda.pyx.in
rename to cuda/cuda/bindings/_bindings/cydriver.pyx.in
index 3561b0be..646744e1 100644
--- a/cuda/_cuda/ccuda.pyx.in
+++ b/cuda/cuda/bindings/_bindings/cydriver.pyx.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -10,11 +10,11 @@ import win32api
 import struct
 from pywintypes import error
 {{else}}
-cimport cuda._lib.dlfcn as dlfcn
+cimport cuda.bindings._lib.dlfcn as dlfcn
 {{endif}}
 import os
 import sys
-cimport cuda._cuda.loader as loader
+cimport cuda.bindings._bindings.loader as loader
 cdef bint __cuPythonInit = False
 {{if 'cuGetErrorString' in found_functions}}cdef void *__cuGetErrorString = NULL{{endif}}
 {{if 'cuGetErrorName' in found_functions}}cdef void *__cuGetErrorName = NULL{{endif}}
@@ -387,25 +387,25 @@ cdef bint __cuPythonInit = False
 {{if 'cuProfilerInitialize' in found_functions}}cdef void *__cuProfilerInitialize = NULL{{endif}}
 {{if 'cuProfilerStart' in found_functions}}cdef void *__cuProfilerStart = NULL{{endif}}
 {{if 'cuProfilerStop' in found_functions}}cdef void *__cuProfilerStop = NULL{{endif}}
-{{if True or 'cuVDPAUGetDevice' in found_functions}}cdef void *__cuVDPAUGetDevice = NULL{{endif}}
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}cdef void *__cuVDPAUCtxCreate_v2 = NULL{{endif}}
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}cdef void *__cuGraphicsVDPAURegisterVideoSurface = NULL{{endif}}
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}cdef void *__cuGraphicsVDPAURegisterOutputSurface = NULL{{endif}}
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}cdef void *__cuGraphicsEGLRegisterImage = NULL{{endif}}
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}cdef void *__cuEGLStreamConsumerConnect = NULL{{endif}}
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}cdef void *__cuEGLStreamConsumerConnectWithFlags = NULL{{endif}}
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}cdef void *__cuEGLStreamConsumerDisconnect = NULL{{endif}}
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}cdef void *__cuEGLStreamConsumerAcquireFrame = NULL{{endif}}
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}cdef void *__cuEGLStreamConsumerReleaseFrame = NULL{{endif}}
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}cdef void *__cuEGLStreamProducerConnect = NULL{{endif}}
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}cdef void *__cuEGLStreamProducerDisconnect = NULL{{endif}}
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}cdef void *__cuEGLStreamProducerPresentFrame = NULL{{endif}}
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}cdef void *__cuEGLStreamProducerReturnFrame = NULL{{endif}}
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}cdef void *__cuGraphicsResourceGetMappedEglFrame = NULL{{endif}}
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}cdef void *__cuEventCreateFromEGLSync = NULL{{endif}}
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}cdef void *__cuGraphicsGLRegisterBuffer = NULL{{endif}}
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}cdef void *__cuGraphicsGLRegisterImage = NULL{{endif}}
-{{if True or 'cuGLGetDevices_v2' in found_functions}}cdef void *__cuGLGetDevices_v2 = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsEGLRegisterImage = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamConsumerConnect = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamConsumerConnectWithFlags = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamConsumerDisconnect = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamConsumerAcquireFrame = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamConsumerReleaseFrame = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamProducerConnect = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamProducerDisconnect = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamProducerPresentFrame = NULL{{endif}}
+{{if True}}cdef void *__cuEGLStreamProducerReturnFrame = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsResourceGetMappedEglFrame = NULL{{endif}}
+{{if True}}cdef void *__cuEventCreateFromEGLSync = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsGLRegisterBuffer = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsGLRegisterImage = NULL{{endif}}
+{{if True}}cdef void *__cuGLGetDevices_v2 = NULL{{endif}}
+{{if True}}cdef void *__cuVDPAUGetDevice = NULL{{endif}}
+{{if True}}cdef void *__cuVDPAUCtxCreate_v2 = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsVDPAURegisterVideoSurface = NULL{{endif}}
+{{if True}}cdef void *__cuGraphicsVDPAURegisterOutputSurface = NULL{{endif}}
 
 cdef int cuPythonInit() except -1 nogil:
     global __cuPythonInit
@@ -2268,82 +2268,82 @@ cdef int cuPythonInit() except -1 nogil:
         global __cuProfilerStop
         cuGetProcAddress('cuProfilerStop', &__cuProfilerStop, 4000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuVDPAUGetDevice' in found_functions}}
-        global __cuVDPAUGetDevice
-        cuGetProcAddress('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
-        {{endif}}
-        {{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-        global __cuVDPAUCtxCreate_v2
-        cuGetProcAddress('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, CU_GET_PROC_ADDRESS_DEFAULT)
-        {{endif}}
-        {{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-        global __cuGraphicsVDPAURegisterVideoSurface
-        cuGetProcAddress('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
-        {{endif}}
-        {{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-        global __cuGraphicsVDPAURegisterOutputSurface
-        cuGetProcAddress('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
-        {{endif}}
-        {{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+        {{if True}}
         global __cuGraphicsEGLRegisterImage
         cuGetProcAddress('cuGraphicsEGLRegisterImage', &__cuGraphicsEGLRegisterImage, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+        {{if True}}
         global __cuEGLStreamConsumerConnect
         cuGetProcAddress('cuEGLStreamConsumerConnect', &__cuEGLStreamConsumerConnect, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+        {{if True}}
         global __cuEGLStreamConsumerConnectWithFlags
         cuGetProcAddress('cuEGLStreamConsumerConnectWithFlags', &__cuEGLStreamConsumerConnectWithFlags, 8000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+        {{if True}}
         global __cuEGLStreamConsumerDisconnect
         cuGetProcAddress('cuEGLStreamConsumerDisconnect', &__cuEGLStreamConsumerDisconnect, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+        {{if True}}
         global __cuEGLStreamConsumerAcquireFrame
         cuGetProcAddress('cuEGLStreamConsumerAcquireFrame', &__cuEGLStreamConsumerAcquireFrame, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+        {{if True}}
         global __cuEGLStreamConsumerReleaseFrame
         cuGetProcAddress('cuEGLStreamConsumerReleaseFrame', &__cuEGLStreamConsumerReleaseFrame, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+        {{if True}}
         global __cuEGLStreamProducerConnect
         cuGetProcAddress('cuEGLStreamProducerConnect', &__cuEGLStreamProducerConnect, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+        {{if True}}
         global __cuEGLStreamProducerDisconnect
         cuGetProcAddress('cuEGLStreamProducerDisconnect', &__cuEGLStreamProducerDisconnect, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+        {{if True}}
         global __cuEGLStreamProducerPresentFrame
         cuGetProcAddress('cuEGLStreamProducerPresentFrame', &__cuEGLStreamProducerPresentFrame, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+        {{if True}}
         global __cuEGLStreamProducerReturnFrame
         cuGetProcAddress('cuEGLStreamProducerReturnFrame', &__cuEGLStreamProducerReturnFrame, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+        {{if True}}
         global __cuGraphicsResourceGetMappedEglFrame
         cuGetProcAddress('cuGraphicsResourceGetMappedEglFrame', &__cuGraphicsResourceGetMappedEglFrame, 7000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+        {{if True}}
         global __cuEventCreateFromEGLSync
         cuGetProcAddress('cuEventCreateFromEGLSync', &__cuEventCreateFromEGLSync, 9000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+        {{if True}}
         global __cuGraphicsGLRegisterBuffer
         cuGetProcAddress('cuGraphicsGLRegisterBuffer', &__cuGraphicsGLRegisterBuffer, 3000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+        {{if True}}
         global __cuGraphicsGLRegisterImage
         cuGetProcAddress('cuGraphicsGLRegisterImage', &__cuGraphicsGLRegisterImage, 3000, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
-        {{if True or 'cuGLGetDevices_v2' in found_functions}}
+        {{if True}}
         global __cuGLGetDevices_v2
         cuGetProcAddress('cuGLGetDevices', &__cuGLGetDevices_v2, 6050, CU_GET_PROC_ADDRESS_DEFAULT)
         {{endif}}
+        {{if True}}
+        global __cuVDPAUGetDevice
+        cuGetProcAddress('cuVDPAUGetDevice', &__cuVDPAUGetDevice, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
+        {{endif}}
+        {{if True}}
+        global __cuVDPAUCtxCreate_v2
+        cuGetProcAddress('cuVDPAUCtxCreate', &__cuVDPAUCtxCreate_v2, 3020, CU_GET_PROC_ADDRESS_DEFAULT)
+        {{endif}}
+        {{if True}}
+        global __cuGraphicsVDPAURegisterVideoSurface
+        cuGetProcAddress('cuGraphicsVDPAURegisterVideoSurface', &__cuGraphicsVDPAURegisterVideoSurface, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
+        {{endif}}
+        {{if True}}
+        global __cuGraphicsVDPAURegisterOutputSurface
+        cuGetProcAddress('cuGraphicsVDPAURegisterOutputSurface', &__cuGraphicsVDPAURegisterOutputSurface, 3010, CU_GET_PROC_ADDRESS_DEFAULT)
+        {{endif}}
         return 0
 
     {{if 'Windows' == platform.system()}}
@@ -5513,139 +5513,139 @@ cdef int cuPythonInit() except -1 nogil:
         except:
             pass
         {{endif}}
-        {{if True or 'cuVDPAUGetDevice' in found_functions}}
-        try:
-            global __cuVDPAUGetDevice
-            __cuVDPAUGetDevice = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuVDPAUGetDevice')
-        except:
-            pass
-        {{endif}}
-        {{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-        try:
-            global __cuVDPAUCtxCreate_v2
-            __cuVDPAUCtxCreate_v2 = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuVDPAUCtxCreate_v2')
-        except:
-            pass
-        {{endif}}
-        {{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-        try:
-            global __cuGraphicsVDPAURegisterVideoSurface
-            __cuGraphicsVDPAURegisterVideoSurface = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsVDPAURegisterVideoSurface')
-        except:
-            pass
-        {{endif}}
-        {{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-        try:
-            global __cuGraphicsVDPAURegisterOutputSurface
-            __cuGraphicsVDPAURegisterOutputSurface = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsVDPAURegisterOutputSurface')
-        except:
-            pass
-        {{endif}}
-        {{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+        {{if True}}
         try:
             global __cuGraphicsEGLRegisterImage
             __cuGraphicsEGLRegisterImage = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsEGLRegisterImage')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamConsumerConnect
             __cuEGLStreamConsumerConnect = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamConsumerConnect')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamConsumerConnectWithFlags
             __cuEGLStreamConsumerConnectWithFlags = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamConsumerConnectWithFlags')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamConsumerDisconnect
             __cuEGLStreamConsumerDisconnect = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamConsumerDisconnect')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamConsumerAcquireFrame
             __cuEGLStreamConsumerAcquireFrame = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamConsumerAcquireFrame')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamConsumerReleaseFrame
             __cuEGLStreamConsumerReleaseFrame = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamConsumerReleaseFrame')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamProducerConnect
             __cuEGLStreamProducerConnect = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamProducerConnect')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamProducerDisconnect
             __cuEGLStreamProducerDisconnect = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamProducerDisconnect')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamProducerPresentFrame
             __cuEGLStreamProducerPresentFrame = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamProducerPresentFrame')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+        {{if True}}
         try:
             global __cuEGLStreamProducerReturnFrame
             __cuEGLStreamProducerReturnFrame = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEGLStreamProducerReturnFrame')
         except:
             pass
         {{endif}}
-        {{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+        {{if True}}
         try:
             global __cuGraphicsResourceGetMappedEglFrame
             __cuGraphicsResourceGetMappedEglFrame = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsResourceGetMappedEglFrame')
         except:
             pass
         {{endif}}
-        {{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+        {{if True}}
         try:
             global __cuEventCreateFromEGLSync
             __cuEventCreateFromEGLSync = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuEventCreateFromEGLSync')
         except:
             pass
         {{endif}}
-        {{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+        {{if True}}
         try:
             global __cuGraphicsGLRegisterBuffer
             __cuGraphicsGLRegisterBuffer = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsGLRegisterBuffer')
         except:
             pass
         {{endif}}
-        {{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+        {{if True}}
         try:
             global __cuGraphicsGLRegisterImage
             __cuGraphicsGLRegisterImage = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsGLRegisterImage')
         except:
             pass
         {{endif}}
-        {{if True or 'cuGLGetDevices_v2' in found_functions}}
+        {{if True}}
         try:
             global __cuGLGetDevices_v2
             __cuGLGetDevices_v2 = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGLGetDevices_v2')
         except:
             pass
         {{endif}}
+        {{if True}}
+        try:
+            global __cuVDPAUGetDevice
+            __cuVDPAUGetDevice = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuVDPAUGetDevice')
+        except:
+            pass
+        {{endif}}
+        {{if True}}
+        try:
+            global __cuVDPAUCtxCreate_v2
+            __cuVDPAUCtxCreate_v2 = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuVDPAUCtxCreate_v2')
+        except:
+            pass
+        {{endif}}
+        {{if True}}
+        try:
+            global __cuGraphicsVDPAURegisterVideoSurface
+            __cuGraphicsVDPAURegisterVideoSurface = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsVDPAURegisterVideoSurface')
+        except:
+            pass
+        {{endif}}
+        {{if True}}
+        try:
+            global __cuGraphicsVDPAURegisterOutputSurface
+            __cuGraphicsVDPAURegisterOutputSurface = <void*><unsigned long long>win32api.GetProcAddress(handle, 'cuGraphicsVDPAURegisterOutputSurface')
+        except:
+            pass
+        {{endif}}
     {{else}}
     # Load using dlsym
     if usePTDS:
@@ -7459,82 +7459,82 @@ cdef int cuPythonInit() except -1 nogil:
     global __cuProfilerStop
     __cuProfilerStop = dlfcn.dlsym(handle, 'cuProfilerStop')
     {{endif}}
-    {{if True or 'cuVDPAUGetDevice' in found_functions}}
-    global __cuVDPAUGetDevice
-    __cuVDPAUGetDevice = dlfcn.dlsym(handle, 'cuVDPAUGetDevice')
-    {{endif}}
-    {{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-    global __cuVDPAUCtxCreate_v2
-    __cuVDPAUCtxCreate_v2 = dlfcn.dlsym(handle, 'cuVDPAUCtxCreate_v2')
-    {{endif}}
-    {{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-    global __cuGraphicsVDPAURegisterVideoSurface
-    __cuGraphicsVDPAURegisterVideoSurface = dlfcn.dlsym(handle, 'cuGraphicsVDPAURegisterVideoSurface')
-    {{endif}}
-    {{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-    global __cuGraphicsVDPAURegisterOutputSurface
-    __cuGraphicsVDPAURegisterOutputSurface = dlfcn.dlsym(handle, 'cuGraphicsVDPAURegisterOutputSurface')
-    {{endif}}
-    {{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+    {{if True}}
     global __cuGraphicsEGLRegisterImage
     __cuGraphicsEGLRegisterImage = dlfcn.dlsym(handle, 'cuGraphicsEGLRegisterImage')
     {{endif}}
-    {{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+    {{if True}}
     global __cuEGLStreamConsumerConnect
     __cuEGLStreamConsumerConnect = dlfcn.dlsym(handle, 'cuEGLStreamConsumerConnect')
     {{endif}}
-    {{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+    {{if True}}
     global __cuEGLStreamConsumerConnectWithFlags
     __cuEGLStreamConsumerConnectWithFlags = dlfcn.dlsym(handle, 'cuEGLStreamConsumerConnectWithFlags')
     {{endif}}
-    {{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+    {{if True}}
     global __cuEGLStreamConsumerDisconnect
     __cuEGLStreamConsumerDisconnect = dlfcn.dlsym(handle, 'cuEGLStreamConsumerDisconnect')
     {{endif}}
-    {{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+    {{if True}}
     global __cuEGLStreamConsumerAcquireFrame
     __cuEGLStreamConsumerAcquireFrame = dlfcn.dlsym(handle, 'cuEGLStreamConsumerAcquireFrame')
     {{endif}}
-    {{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+    {{if True}}
     global __cuEGLStreamConsumerReleaseFrame
     __cuEGLStreamConsumerReleaseFrame = dlfcn.dlsym(handle, 'cuEGLStreamConsumerReleaseFrame')
     {{endif}}
-    {{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+    {{if True}}
     global __cuEGLStreamProducerConnect
     __cuEGLStreamProducerConnect = dlfcn.dlsym(handle, 'cuEGLStreamProducerConnect')
     {{endif}}
-    {{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+    {{if True}}
     global __cuEGLStreamProducerDisconnect
     __cuEGLStreamProducerDisconnect = dlfcn.dlsym(handle, 'cuEGLStreamProducerDisconnect')
     {{endif}}
-    {{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+    {{if True}}
     global __cuEGLStreamProducerPresentFrame
     __cuEGLStreamProducerPresentFrame = dlfcn.dlsym(handle, 'cuEGLStreamProducerPresentFrame')
     {{endif}}
-    {{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+    {{if True}}
     global __cuEGLStreamProducerReturnFrame
     __cuEGLStreamProducerReturnFrame = dlfcn.dlsym(handle, 'cuEGLStreamProducerReturnFrame')
     {{endif}}
-    {{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+    {{if True}}
     global __cuGraphicsResourceGetMappedEglFrame
     __cuGraphicsResourceGetMappedEglFrame = dlfcn.dlsym(handle, 'cuGraphicsResourceGetMappedEglFrame')
     {{endif}}
-    {{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+    {{if True}}
     global __cuEventCreateFromEGLSync
     __cuEventCreateFromEGLSync = dlfcn.dlsym(handle, 'cuEventCreateFromEGLSync')
     {{endif}}
-    {{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+    {{if True}}
     global __cuGraphicsGLRegisterBuffer
     __cuGraphicsGLRegisterBuffer = dlfcn.dlsym(handle, 'cuGraphicsGLRegisterBuffer')
     {{endif}}
-    {{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+    {{if True}}
     global __cuGraphicsGLRegisterImage
     __cuGraphicsGLRegisterImage = dlfcn.dlsym(handle, 'cuGraphicsGLRegisterImage')
     {{endif}}
-    {{if True or 'cuGLGetDevices_v2' in found_functions}}
+    {{if True}}
     global __cuGLGetDevices_v2
     __cuGLGetDevices_v2 = dlfcn.dlsym(handle, 'cuGLGetDevices_v2')
     {{endif}}
+    {{if True}}
+    global __cuVDPAUGetDevice
+    __cuVDPAUGetDevice = dlfcn.dlsym(handle, 'cuVDPAUGetDevice')
+    {{endif}}
+    {{if True}}
+    global __cuVDPAUCtxCreate_v2
+    __cuVDPAUCtxCreate_v2 = dlfcn.dlsym(handle, 'cuVDPAUCtxCreate_v2')
+    {{endif}}
+    {{if True}}
+    global __cuGraphicsVDPAURegisterVideoSurface
+    __cuGraphicsVDPAURegisterVideoSurface = dlfcn.dlsym(handle, 'cuGraphicsVDPAURegisterVideoSurface')
+    {{endif}}
+    {{if True}}
+    global __cuGraphicsVDPAURegisterOutputSurface
+    __cuGraphicsVDPAURegisterOutputSurface = dlfcn.dlsym(handle, 'cuGraphicsVDPAURegisterOutputSurface')
+    {{endif}}
     {{endif}}
 
 {{if 'cuGetErrorString' in found_functions}}
@@ -7545,7 +7545,7 @@ cdef CUresult _cuGetErrorString(CUresult error, const char** pStr) except ?CUDA_
     if __cuGetErrorString == NULL:
         with gil:
             raise RuntimeError('Function "cuGetErrorString" not found')
-    err = (<CUresult (*)(CUresult, const char**) nogil> __cuGetErrorString)(error, pStr)
+    err = (<CUresult (*)(CUresult, const char**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGetErrorString)(error, pStr)
     return err
 {{endif}}
 
@@ -7557,7 +7557,7 @@ cdef CUresult _cuGetErrorName(CUresult error, const char** pStr) except ?CUDA_ER
     if __cuGetErrorName == NULL:
         with gil:
             raise RuntimeError('Function "cuGetErrorName" not found')
-    err = (<CUresult (*)(CUresult, const char**) nogil> __cuGetErrorName)(error, pStr)
+    err = (<CUresult (*)(CUresult, const char**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGetErrorName)(error, pStr)
     return err
 {{endif}}
 
@@ -7569,7 +7569,7 @@ cdef CUresult _cuInit(unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuInit == NULL:
         with gil:
             raise RuntimeError('Function "cuInit" not found')
-    err = (<CUresult (*)(unsigned int) nogil> __cuInit)(Flags)
+    err = (<CUresult (*)(unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuInit)(Flags)
     return err
 {{endif}}
 
@@ -7581,7 +7581,7 @@ cdef CUresult _cuDriverGetVersion(int* driverVersion) except ?CUDA_ERROR_NOT_FOU
     if __cuDriverGetVersion == NULL:
         with gil:
             raise RuntimeError('Function "cuDriverGetVersion" not found')
-    err = (<CUresult (*)(int*) nogil> __cuDriverGetVersion)(driverVersion)
+    err = (<CUresult (*)(int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDriverGetVersion)(driverVersion)
     return err
 {{endif}}
 
@@ -7593,7 +7593,7 @@ cdef CUresult _cuDeviceGet(CUdevice* device, int ordinal) except ?CUDA_ERROR_NOT
     if __cuDeviceGet == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGet" not found')
-    err = (<CUresult (*)(CUdevice*, int) nogil> __cuDeviceGet)(device, ordinal)
+    err = (<CUresult (*)(CUdevice*, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGet)(device, ordinal)
     return err
 {{endif}}
 
@@ -7605,7 +7605,7 @@ cdef CUresult _cuDeviceGetCount(int* count) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuDeviceGetCount == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetCount" not found')
-    err = (<CUresult (*)(int*) nogil> __cuDeviceGetCount)(count)
+    err = (<CUresult (*)(int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetCount)(count)
     return err
 {{endif}}
 
@@ -7617,7 +7617,7 @@ cdef CUresult _cuDeviceGetName(char* name, int length, CUdevice dev) except ?CUD
     if __cuDeviceGetName == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetName" not found')
-    err = (<CUresult (*)(char*, int, CUdevice) nogil> __cuDeviceGetName)(name, length, dev)
+    err = (<CUresult (*)(char*, int, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetName)(name, length, dev)
     return err
 {{endif}}
 
@@ -7629,7 +7629,7 @@ cdef CUresult _cuDeviceGetUuid(CUuuid* uuid, CUdevice dev) except ?CUDA_ERROR_NO
     if __cuDeviceGetUuid == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetUuid" not found')
-    err = (<CUresult (*)(CUuuid*, CUdevice) nogil> __cuDeviceGetUuid)(uuid, dev)
+    err = (<CUresult (*)(CUuuid*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetUuid)(uuid, dev)
     return err
 {{endif}}
 
@@ -7641,7 +7641,7 @@ cdef CUresult _cuDeviceGetUuid_v2(CUuuid* uuid, CUdevice dev) except ?CUDA_ERROR
     if __cuDeviceGetUuid_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetUuid_v2" not found')
-    err = (<CUresult (*)(CUuuid*, CUdevice) nogil> __cuDeviceGetUuid_v2)(uuid, dev)
+    err = (<CUresult (*)(CUuuid*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetUuid_v2)(uuid, dev)
     return err
 {{endif}}
 
@@ -7653,7 +7653,7 @@ cdef CUresult _cuDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, CUdevic
     if __cuDeviceGetLuid == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetLuid" not found')
-    err = (<CUresult (*)(char*, unsigned int*, CUdevice) nogil> __cuDeviceGetLuid)(luid, deviceNodeMask, dev)
+    err = (<CUresult (*)(char*, unsigned int*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetLuid)(luid, deviceNodeMask, dev)
     return err
 {{endif}}
 
@@ -7665,7 +7665,7 @@ cdef CUresult _cuDeviceTotalMem_v2(size_t* numbytes, CUdevice dev) except ?CUDA_
     if __cuDeviceTotalMem_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceTotalMem_v2" not found')
-    err = (<CUresult (*)(size_t*, CUdevice) nogil> __cuDeviceTotalMem_v2)(numbytes, dev)
+    err = (<CUresult (*)(size_t*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceTotalMem_v2)(numbytes, dev)
     return err
 {{endif}}
 
@@ -7677,7 +7677,7 @@ cdef CUresult _cuDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, CU
     if __cuDeviceGetTexture1DLinearMaxWidth == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetTexture1DLinearMaxWidth" not found')
-    err = (<CUresult (*)(size_t*, CUarray_format, unsigned, CUdevice) nogil> __cuDeviceGetTexture1DLinearMaxWidth)(maxWidthInElements, pformat, numChannels, dev)
+    err = (<CUresult (*)(size_t*, CUarray_format, unsigned, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetTexture1DLinearMaxWidth)(maxWidthInElements, pformat, numChannels, dev)
     return err
 {{endif}}
 
@@ -7689,7 +7689,7 @@ cdef CUresult _cuDeviceGetAttribute(int* pi, CUdevice_attribute attrib, CUdevice
     if __cuDeviceGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetAttribute" not found')
-    err = (<CUresult (*)(int*, CUdevice_attribute, CUdevice) nogil> __cuDeviceGetAttribute)(pi, attrib, dev)
+    err = (<CUresult (*)(int*, CUdevice_attribute, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetAttribute)(pi, attrib, dev)
     return err
 {{endif}}
 
@@ -7701,7 +7701,7 @@ cdef CUresult _cuDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, CUdevice
     if __cuDeviceGetNvSciSyncAttributes == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetNvSciSyncAttributes" not found')
-    err = (<CUresult (*)(void*, CUdevice, int) nogil> __cuDeviceGetNvSciSyncAttributes)(nvSciSyncAttrList, dev, flags)
+    err = (<CUresult (*)(void*, CUdevice, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetNvSciSyncAttributes)(nvSciSyncAttrList, dev, flags)
     return err
 {{endif}}
 
@@ -7713,7 +7713,7 @@ cdef CUresult _cuDeviceSetMemPool(CUdevice dev, CUmemoryPool pool) except ?CUDA_
     if __cuDeviceSetMemPool == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceSetMemPool" not found')
-    err = (<CUresult (*)(CUdevice, CUmemoryPool) nogil> __cuDeviceSetMemPool)(dev, pool)
+    err = (<CUresult (*)(CUdevice, CUmemoryPool) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceSetMemPool)(dev, pool)
     return err
 {{endif}}
 
@@ -7725,7 +7725,7 @@ cdef CUresult _cuDeviceGetMemPool(CUmemoryPool* pool, CUdevice dev) except ?CUDA
     if __cuDeviceGetMemPool == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetMemPool" not found')
-    err = (<CUresult (*)(CUmemoryPool*, CUdevice) nogil> __cuDeviceGetMemPool)(pool, dev)
+    err = (<CUresult (*)(CUmemoryPool*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetMemPool)(pool, dev)
     return err
 {{endif}}
 
@@ -7737,7 +7737,7 @@ cdef CUresult _cuDeviceGetDefaultMemPool(CUmemoryPool* pool_out, CUdevice dev) e
     if __cuDeviceGetDefaultMemPool == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetDefaultMemPool" not found')
-    err = (<CUresult (*)(CUmemoryPool*, CUdevice) nogil> __cuDeviceGetDefaultMemPool)(pool_out, dev)
+    err = (<CUresult (*)(CUmemoryPool*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetDefaultMemPool)(pool_out, dev)
     return err
 {{endif}}
 
@@ -7749,7 +7749,7 @@ cdef CUresult _cuFlushGPUDirectRDMAWrites(CUflushGPUDirectRDMAWritesTarget targe
     if __cuFlushGPUDirectRDMAWrites == NULL:
         with gil:
             raise RuntimeError('Function "cuFlushGPUDirectRDMAWrites" not found')
-    err = (<CUresult (*)(CUflushGPUDirectRDMAWritesTarget, CUflushGPUDirectRDMAWritesScope) nogil> __cuFlushGPUDirectRDMAWrites)(target, scope)
+    err = (<CUresult (*)(CUflushGPUDirectRDMAWritesTarget, CUflushGPUDirectRDMAWritesScope) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFlushGPUDirectRDMAWrites)(target, scope)
     return err
 {{endif}}
 
@@ -7761,7 +7761,7 @@ cdef CUresult _cuDeviceGetProperties(CUdevprop* prop, CUdevice dev) except ?CUDA
     if __cuDeviceGetProperties == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetProperties" not found')
-    err = (<CUresult (*)(CUdevprop*, CUdevice) nogil> __cuDeviceGetProperties)(prop, dev)
+    err = (<CUresult (*)(CUdevprop*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetProperties)(prop, dev)
     return err
 {{endif}}
 
@@ -7773,7 +7773,7 @@ cdef CUresult _cuDeviceComputeCapability(int* major, int* minor, CUdevice dev) e
     if __cuDeviceComputeCapability == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceComputeCapability" not found')
-    err = (<CUresult (*)(int*, int*, CUdevice) nogil> __cuDeviceComputeCapability)(major, minor, dev)
+    err = (<CUresult (*)(int*, int*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceComputeCapability)(major, minor, dev)
     return err
 {{endif}}
 
@@ -7785,7 +7785,7 @@ cdef CUresult _cuDevicePrimaryCtxRetain(CUcontext* pctx, CUdevice dev) except ?C
     if __cuDevicePrimaryCtxRetain == NULL:
         with gil:
             raise RuntimeError('Function "cuDevicePrimaryCtxRetain" not found')
-    err = (<CUresult (*)(CUcontext*, CUdevice) nogil> __cuDevicePrimaryCtxRetain)(pctx, dev)
+    err = (<CUresult (*)(CUcontext*, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDevicePrimaryCtxRetain)(pctx, dev)
     return err
 {{endif}}
 
@@ -7797,7 +7797,7 @@ cdef CUresult _cuDevicePrimaryCtxRelease_v2(CUdevice dev) except ?CUDA_ERROR_NOT
     if __cuDevicePrimaryCtxRelease_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuDevicePrimaryCtxRelease_v2" not found')
-    err = (<CUresult (*)(CUdevice) nogil> __cuDevicePrimaryCtxRelease_v2)(dev)
+    err = (<CUresult (*)(CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDevicePrimaryCtxRelease_v2)(dev)
     return err
 {{endif}}
 
@@ -7809,7 +7809,7 @@ cdef CUresult _cuDevicePrimaryCtxSetFlags_v2(CUdevice dev, unsigned int flags) e
     if __cuDevicePrimaryCtxSetFlags_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuDevicePrimaryCtxSetFlags_v2" not found')
-    err = (<CUresult (*)(CUdevice, unsigned int) nogil> __cuDevicePrimaryCtxSetFlags_v2)(dev, flags)
+    err = (<CUresult (*)(CUdevice, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDevicePrimaryCtxSetFlags_v2)(dev, flags)
     return err
 {{endif}}
 
@@ -7821,7 +7821,7 @@ cdef CUresult _cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int* flags, int
     if __cuDevicePrimaryCtxGetState == NULL:
         with gil:
             raise RuntimeError('Function "cuDevicePrimaryCtxGetState" not found')
-    err = (<CUresult (*)(CUdevice, unsigned int*, int*) nogil> __cuDevicePrimaryCtxGetState)(dev, flags, active)
+    err = (<CUresult (*)(CUdevice, unsigned int*, int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDevicePrimaryCtxGetState)(dev, flags, active)
     return err
 {{endif}}
 
@@ -7833,7 +7833,7 @@ cdef CUresult _cuDevicePrimaryCtxReset_v2(CUdevice dev) except ?CUDA_ERROR_NOT_F
     if __cuDevicePrimaryCtxReset_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuDevicePrimaryCtxReset_v2" not found')
-    err = (<CUresult (*)(CUdevice) nogil> __cuDevicePrimaryCtxReset_v2)(dev)
+    err = (<CUresult (*)(CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDevicePrimaryCtxReset_v2)(dev)
     return err
 {{endif}}
 
@@ -7845,7 +7845,7 @@ cdef CUresult _cuDeviceGetExecAffinitySupport(int* pi, CUexecAffinityType typena
     if __cuDeviceGetExecAffinitySupport == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetExecAffinitySupport" not found')
-    err = (<CUresult (*)(int*, CUexecAffinityType, CUdevice) nogil> __cuDeviceGetExecAffinitySupport)(pi, typename, dev)
+    err = (<CUresult (*)(int*, CUexecAffinityType, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetExecAffinitySupport)(pi, typename, dev)
     return err
 {{endif}}
 
@@ -7857,7 +7857,7 @@ cdef CUresult _cuCtxCreate_v2(CUcontext* pctx, unsigned int flags, CUdevice dev)
     if __cuCtxCreate_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxCreate_v2" not found')
-    err = (<CUresult (*)(CUcontext*, unsigned int, CUdevice) nogil> __cuCtxCreate_v2)(pctx, flags, dev)
+    err = (<CUresult (*)(CUcontext*, unsigned int, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxCreate_v2)(pctx, flags, dev)
     return err
 {{endif}}
 
@@ -7869,7 +7869,7 @@ cdef CUresult _cuCtxCreate_v3(CUcontext* pctx, CUexecAffinityParam* paramsArray,
     if __cuCtxCreate_v3 == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxCreate_v3" not found')
-    err = (<CUresult (*)(CUcontext*, CUexecAffinityParam*, int, unsigned int, CUdevice) nogil> __cuCtxCreate_v3)(pctx, paramsArray, numParams, flags, dev)
+    err = (<CUresult (*)(CUcontext*, CUexecAffinityParam*, int, unsigned int, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxCreate_v3)(pctx, paramsArray, numParams, flags, dev)
     return err
 {{endif}}
 
@@ -7881,7 +7881,7 @@ cdef CUresult _cuCtxDestroy_v2(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil
     if __cuCtxDestroy_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxDestroy_v2" not found')
-    err = (<CUresult (*)(CUcontext) nogil> __cuCtxDestroy_v2)(ctx)
+    err = (<CUresult (*)(CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxDestroy_v2)(ctx)
     return err
 {{endif}}
 
@@ -7893,7 +7893,7 @@ cdef CUresult _cuCtxPushCurrent_v2(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND n
     if __cuCtxPushCurrent_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxPushCurrent_v2" not found')
-    err = (<CUresult (*)(CUcontext) nogil> __cuCtxPushCurrent_v2)(ctx)
+    err = (<CUresult (*)(CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxPushCurrent_v2)(ctx)
     return err
 {{endif}}
 
@@ -7905,7 +7905,7 @@ cdef CUresult _cuCtxPopCurrent_v2(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND
     if __cuCtxPopCurrent_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxPopCurrent_v2" not found')
-    err = (<CUresult (*)(CUcontext*) nogil> __cuCtxPopCurrent_v2)(pctx)
+    err = (<CUresult (*)(CUcontext*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxPopCurrent_v2)(pctx)
     return err
 {{endif}}
 
@@ -7917,7 +7917,7 @@ cdef CUresult _cuCtxSetCurrent(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil
     if __cuCtxSetCurrent == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxSetCurrent" not found')
-    err = (<CUresult (*)(CUcontext) nogil> __cuCtxSetCurrent)(ctx)
+    err = (<CUresult (*)(CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxSetCurrent)(ctx)
     return err
 {{endif}}
 
@@ -7929,7 +7929,7 @@ cdef CUresult _cuCtxGetCurrent(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nog
     if __cuCtxGetCurrent == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetCurrent" not found')
-    err = (<CUresult (*)(CUcontext*) nogil> __cuCtxGetCurrent)(pctx)
+    err = (<CUresult (*)(CUcontext*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetCurrent)(pctx)
     return err
 {{endif}}
 
@@ -7941,7 +7941,7 @@ cdef CUresult _cuCtxGetDevice(CUdevice* device) except ?CUDA_ERROR_NOT_FOUND nog
     if __cuCtxGetDevice == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetDevice" not found')
-    err = (<CUresult (*)(CUdevice*) nogil> __cuCtxGetDevice)(device)
+    err = (<CUresult (*)(CUdevice*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetDevice)(device)
     return err
 {{endif}}
 
@@ -7953,7 +7953,7 @@ cdef CUresult _cuCtxGetFlags(unsigned int* flags) except ?CUDA_ERROR_NOT_FOUND n
     if __cuCtxGetFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetFlags" not found')
-    err = (<CUresult (*)(unsigned int*) nogil> __cuCtxGetFlags)(flags)
+    err = (<CUresult (*)(unsigned int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetFlags)(flags)
     return err
 {{endif}}
 
@@ -7965,7 +7965,7 @@ cdef CUresult _cuCtxSynchronize() except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuCtxSynchronize == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxSynchronize" not found')
-    err = (<CUresult (*)() nogil> __cuCtxSynchronize)()
+    err = (<CUresult (*)() except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxSynchronize)()
     return err
 {{endif}}
 
@@ -7977,7 +7977,7 @@ cdef CUresult _cuCtxSetLimit(CUlimit limit, size_t value) except ?CUDA_ERROR_NOT
     if __cuCtxSetLimit == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxSetLimit" not found')
-    err = (<CUresult (*)(CUlimit, size_t) nogil> __cuCtxSetLimit)(limit, value)
+    err = (<CUresult (*)(CUlimit, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxSetLimit)(limit, value)
     return err
 {{endif}}
 
@@ -7989,7 +7989,7 @@ cdef CUresult _cuCtxGetLimit(size_t* pvalue, CUlimit limit) except ?CUDA_ERROR_N
     if __cuCtxGetLimit == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetLimit" not found')
-    err = (<CUresult (*)(size_t*, CUlimit) nogil> __cuCtxGetLimit)(pvalue, limit)
+    err = (<CUresult (*)(size_t*, CUlimit) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetLimit)(pvalue, limit)
     return err
 {{endif}}
 
@@ -8001,7 +8001,7 @@ cdef CUresult _cuCtxGetCacheConfig(CUfunc_cache* pconfig) except ?CUDA_ERROR_NOT
     if __cuCtxGetCacheConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetCacheConfig" not found')
-    err = (<CUresult (*)(CUfunc_cache*) nogil> __cuCtxGetCacheConfig)(pconfig)
+    err = (<CUresult (*)(CUfunc_cache*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetCacheConfig)(pconfig)
     return err
 {{endif}}
 
@@ -8013,7 +8013,7 @@ cdef CUresult _cuCtxSetCacheConfig(CUfunc_cache config) except ?CUDA_ERROR_NOT_F
     if __cuCtxSetCacheConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxSetCacheConfig" not found')
-    err = (<CUresult (*)(CUfunc_cache) nogil> __cuCtxSetCacheConfig)(config)
+    err = (<CUresult (*)(CUfunc_cache) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxSetCacheConfig)(config)
     return err
 {{endif}}
 
@@ -8025,7 +8025,7 @@ cdef CUresult _cuCtxGetSharedMemConfig(CUsharedconfig* pConfig) except ?CUDA_ERR
     if __cuCtxGetSharedMemConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetSharedMemConfig" not found')
-    err = (<CUresult (*)(CUsharedconfig*) nogil> __cuCtxGetSharedMemConfig)(pConfig)
+    err = (<CUresult (*)(CUsharedconfig*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetSharedMemConfig)(pConfig)
     return err
 {{endif}}
 
@@ -8037,7 +8037,7 @@ cdef CUresult _cuCtxSetSharedMemConfig(CUsharedconfig config) except ?CUDA_ERROR
     if __cuCtxSetSharedMemConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxSetSharedMemConfig" not found')
-    err = (<CUresult (*)(CUsharedconfig) nogil> __cuCtxSetSharedMemConfig)(config)
+    err = (<CUresult (*)(CUsharedconfig) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxSetSharedMemConfig)(config)
     return err
 {{endif}}
 
@@ -8049,7 +8049,7 @@ cdef CUresult _cuCtxGetApiVersion(CUcontext ctx, unsigned int* version) except ?
     if __cuCtxGetApiVersion == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetApiVersion" not found')
-    err = (<CUresult (*)(CUcontext, unsigned int*) nogil> __cuCtxGetApiVersion)(ctx, version)
+    err = (<CUresult (*)(CUcontext, unsigned int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetApiVersion)(ctx, version)
     return err
 {{endif}}
 
@@ -8061,7 +8061,7 @@ cdef CUresult _cuCtxGetStreamPriorityRange(int* leastPriority, int* greatestPrio
     if __cuCtxGetStreamPriorityRange == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetStreamPriorityRange" not found')
-    err = (<CUresult (*)(int*, int*) nogil> __cuCtxGetStreamPriorityRange)(leastPriority, greatestPriority)
+    err = (<CUresult (*)(int*, int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetStreamPriorityRange)(leastPriority, greatestPriority)
     return err
 {{endif}}
 
@@ -8073,7 +8073,7 @@ cdef CUresult _cuCtxResetPersistingL2Cache() except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuCtxResetPersistingL2Cache == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxResetPersistingL2Cache" not found')
-    err = (<CUresult (*)() nogil> __cuCtxResetPersistingL2Cache)()
+    err = (<CUresult (*)() except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxResetPersistingL2Cache)()
     return err
 {{endif}}
 
@@ -8085,7 +8085,7 @@ cdef CUresult _cuCtxGetExecAffinity(CUexecAffinityParam* pExecAffinity, CUexecAf
     if __cuCtxGetExecAffinity == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxGetExecAffinity" not found')
-    err = (<CUresult (*)(CUexecAffinityParam*, CUexecAffinityType) nogil> __cuCtxGetExecAffinity)(pExecAffinity, typename)
+    err = (<CUresult (*)(CUexecAffinityParam*, CUexecAffinityType) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxGetExecAffinity)(pExecAffinity, typename)
     return err
 {{endif}}
 
@@ -8097,7 +8097,7 @@ cdef CUresult _cuCtxAttach(CUcontext* pctx, unsigned int flags) except ?CUDA_ERR
     if __cuCtxAttach == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxAttach" not found')
-    err = (<CUresult (*)(CUcontext*, unsigned int) nogil> __cuCtxAttach)(pctx, flags)
+    err = (<CUresult (*)(CUcontext*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxAttach)(pctx, flags)
     return err
 {{endif}}
 
@@ -8109,7 +8109,7 @@ cdef CUresult _cuCtxDetach(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuCtxDetach == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxDetach" not found')
-    err = (<CUresult (*)(CUcontext) nogil> __cuCtxDetach)(ctx)
+    err = (<CUresult (*)(CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxDetach)(ctx)
     return err
 {{endif}}
 
@@ -8121,7 +8121,7 @@ cdef CUresult _cuModuleLoad(CUmodule* module, const char* fname) except ?CUDA_ER
     if __cuModuleLoad == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleLoad" not found')
-    err = (<CUresult (*)(CUmodule*, const char*) nogil> __cuModuleLoad)(module, fname)
+    err = (<CUresult (*)(CUmodule*, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleLoad)(module, fname)
     return err
 {{endif}}
 
@@ -8133,7 +8133,7 @@ cdef CUresult _cuModuleLoadData(CUmodule* module, const void* image) except ?CUD
     if __cuModuleLoadData == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleLoadData" not found')
-    err = (<CUresult (*)(CUmodule*, const void*) nogil> __cuModuleLoadData)(module, image)
+    err = (<CUresult (*)(CUmodule*, const void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleLoadData)(module, image)
     return err
 {{endif}}
 
@@ -8145,7 +8145,7 @@ cdef CUresult _cuModuleLoadDataEx(CUmodule* module, const void* image, unsigned
     if __cuModuleLoadDataEx == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleLoadDataEx" not found')
-    err = (<CUresult (*)(CUmodule*, const void*, unsigned int, CUjit_option*, void**) nogil> __cuModuleLoadDataEx)(module, image, numOptions, options, optionValues)
+    err = (<CUresult (*)(CUmodule*, const void*, unsigned int, CUjit_option*, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleLoadDataEx)(module, image, numOptions, options, optionValues)
     return err
 {{endif}}
 
@@ -8157,7 +8157,7 @@ cdef CUresult _cuModuleLoadFatBinary(CUmodule* module, const void* fatCubin) exc
     if __cuModuleLoadFatBinary == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleLoadFatBinary" not found')
-    err = (<CUresult (*)(CUmodule*, const void*) nogil> __cuModuleLoadFatBinary)(module, fatCubin)
+    err = (<CUresult (*)(CUmodule*, const void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleLoadFatBinary)(module, fatCubin)
     return err
 {{endif}}
 
@@ -8169,7 +8169,7 @@ cdef CUresult _cuModuleUnload(CUmodule hmod) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuModuleUnload == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleUnload" not found')
-    err = (<CUresult (*)(CUmodule) nogil> __cuModuleUnload)(hmod)
+    err = (<CUresult (*)(CUmodule) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleUnload)(hmod)
     return err
 {{endif}}
 
@@ -8181,7 +8181,7 @@ cdef CUresult _cuModuleGetLoadingMode(CUmoduleLoadingMode* mode) except ?CUDA_ER
     if __cuModuleGetLoadingMode == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleGetLoadingMode" not found')
-    err = (<CUresult (*)(CUmoduleLoadingMode*) nogil> __cuModuleGetLoadingMode)(mode)
+    err = (<CUresult (*)(CUmoduleLoadingMode*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleGetLoadingMode)(mode)
     return err
 {{endif}}
 
@@ -8193,7 +8193,7 @@ cdef CUresult _cuModuleGetFunction(CUfunction* hfunc, CUmodule hmod, const char*
     if __cuModuleGetFunction == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleGetFunction" not found')
-    err = (<CUresult (*)(CUfunction*, CUmodule, const char*) nogil> __cuModuleGetFunction)(hfunc, hmod, name)
+    err = (<CUresult (*)(CUfunction*, CUmodule, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleGetFunction)(hfunc, hmod, name)
     return err
 {{endif}}
 
@@ -8205,7 +8205,7 @@ cdef CUresult _cuModuleGetGlobal_v2(CUdeviceptr* dptr, size_t* numbytes, CUmodul
     if __cuModuleGetGlobal_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleGetGlobal_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUmodule, const char*) nogil> __cuModuleGetGlobal_v2)(dptr, numbytes, hmod, name)
+    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUmodule, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleGetGlobal_v2)(dptr, numbytes, hmod, name)
     return err
 {{endif}}
 
@@ -8217,7 +8217,7 @@ cdef CUresult _cuModuleGetTexRef(CUtexref* pTexRef, CUmodule hmod, const char* n
     if __cuModuleGetTexRef == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleGetTexRef" not found')
-    err = (<CUresult (*)(CUtexref*, CUmodule, const char*) nogil> __cuModuleGetTexRef)(pTexRef, hmod, name)
+    err = (<CUresult (*)(CUtexref*, CUmodule, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleGetTexRef)(pTexRef, hmod, name)
     return err
 {{endif}}
 
@@ -8229,7 +8229,7 @@ cdef CUresult _cuModuleGetSurfRef(CUsurfref* pSurfRef, CUmodule hmod, const char
     if __cuModuleGetSurfRef == NULL:
         with gil:
             raise RuntimeError('Function "cuModuleGetSurfRef" not found')
-    err = (<CUresult (*)(CUsurfref*, CUmodule, const char*) nogil> __cuModuleGetSurfRef)(pSurfRef, hmod, name)
+    err = (<CUresult (*)(CUsurfref*, CUmodule, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuModuleGetSurfRef)(pSurfRef, hmod, name)
     return err
 {{endif}}
 
@@ -8241,7 +8241,7 @@ cdef CUresult _cuLinkCreate_v2(unsigned int numOptions, CUjit_option* options, v
     if __cuLinkCreate_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuLinkCreate_v2" not found')
-    err = (<CUresult (*)(unsigned int, CUjit_option*, void**, CUlinkState*) nogil> __cuLinkCreate_v2)(numOptions, options, optionValues, stateOut)
+    err = (<CUresult (*)(unsigned int, CUjit_option*, void**, CUlinkState*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLinkCreate_v2)(numOptions, options, optionValues, stateOut)
     return err
 {{endif}}
 
@@ -8253,7 +8253,7 @@ cdef CUresult _cuLinkAddData_v2(CUlinkState state, CUjitInputType typename, void
     if __cuLinkAddData_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuLinkAddData_v2" not found')
-    err = (<CUresult (*)(CUlinkState, CUjitInputType, void*, size_t, const char*, unsigned int, CUjit_option*, void**) nogil> __cuLinkAddData_v2)(state, typename, data, size, name, numOptions, options, optionValues)
+    err = (<CUresult (*)(CUlinkState, CUjitInputType, void*, size_t, const char*, unsigned int, CUjit_option*, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLinkAddData_v2)(state, typename, data, size, name, numOptions, options, optionValues)
     return err
 {{endif}}
 
@@ -8265,7 +8265,7 @@ cdef CUresult _cuLinkAddFile_v2(CUlinkState state, CUjitInputType typename, cons
     if __cuLinkAddFile_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuLinkAddFile_v2" not found')
-    err = (<CUresult (*)(CUlinkState, CUjitInputType, const char*, unsigned int, CUjit_option*, void**) nogil> __cuLinkAddFile_v2)(state, typename, path, numOptions, options, optionValues)
+    err = (<CUresult (*)(CUlinkState, CUjitInputType, const char*, unsigned int, CUjit_option*, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLinkAddFile_v2)(state, typename, path, numOptions, options, optionValues)
     return err
 {{endif}}
 
@@ -8277,7 +8277,7 @@ cdef CUresult _cuLinkComplete(CUlinkState state, void** cubinOut, size_t* sizeOu
     if __cuLinkComplete == NULL:
         with gil:
             raise RuntimeError('Function "cuLinkComplete" not found')
-    err = (<CUresult (*)(CUlinkState, void**, size_t*) nogil> __cuLinkComplete)(state, cubinOut, sizeOut)
+    err = (<CUresult (*)(CUlinkState, void**, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLinkComplete)(state, cubinOut, sizeOut)
     return err
 {{endif}}
 
@@ -8289,7 +8289,7 @@ cdef CUresult _cuLinkDestroy(CUlinkState state) except ?CUDA_ERROR_NOT_FOUND nog
     if __cuLinkDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuLinkDestroy" not found')
-    err = (<CUresult (*)(CUlinkState) nogil> __cuLinkDestroy)(state)
+    err = (<CUresult (*)(CUlinkState) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLinkDestroy)(state)
     return err
 {{endif}}
 
@@ -8301,7 +8301,7 @@ cdef CUresult _cuMemGetInfo_v2(size_t* free, size_t* total) except ?CUDA_ERROR_N
     if __cuMemGetInfo_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetInfo_v2" not found')
-    err = (<CUresult (*)(size_t*, size_t*) nogil> __cuMemGetInfo_v2)(free, total)
+    err = (<CUresult (*)(size_t*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetInfo_v2)(free, total)
     return err
 {{endif}}
 
@@ -8313,7 +8313,7 @@ cdef CUresult _cuMemAlloc_v2(CUdeviceptr* dptr, size_t bytesize) except ?CUDA_ER
     if __cuMemAlloc_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAlloc_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t) nogil> __cuMemAlloc_v2)(dptr, bytesize)
+    err = (<CUresult (*)(CUdeviceptr*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAlloc_v2)(dptr, bytesize)
     return err
 {{endif}}
 
@@ -8325,7 +8325,7 @@ cdef CUresult _cuMemAllocPitch_v2(CUdeviceptr* dptr, size_t* pPitch, size_t Widt
     if __cuMemAllocPitch_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAllocPitch_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t*, size_t, size_t, unsigned int) nogil> __cuMemAllocPitch_v2)(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes)
+    err = (<CUresult (*)(CUdeviceptr*, size_t*, size_t, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAllocPitch_v2)(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes)
     return err
 {{endif}}
 
@@ -8337,7 +8337,7 @@ cdef CUresult _cuMemFree_v2(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil
     if __cuMemFree_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemFree_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr) nogil> __cuMemFree_v2)(dptr)
+    err = (<CUresult (*)(CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemFree_v2)(dptr)
     return err
 {{endif}}
 
@@ -8349,7 +8349,7 @@ cdef CUresult _cuMemGetAddressRange_v2(CUdeviceptr* pbase, size_t* psize, CUdevi
     if __cuMemGetAddressRange_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetAddressRange_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUdeviceptr) nogil> __cuMemGetAddressRange_v2)(pbase, psize, dptr)
+    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetAddressRange_v2)(pbase, psize, dptr)
     return err
 {{endif}}
 
@@ -8361,7 +8361,7 @@ cdef CUresult _cuMemAllocHost_v2(void** pp, size_t bytesize) except ?CUDA_ERROR_
     if __cuMemAllocHost_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAllocHost_v2" not found')
-    err = (<CUresult (*)(void**, size_t) nogil> __cuMemAllocHost_v2)(pp, bytesize)
+    err = (<CUresult (*)(void**, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAllocHost_v2)(pp, bytesize)
     return err
 {{endif}}
 
@@ -8373,7 +8373,7 @@ cdef CUresult _cuMemFreeHost(void* p) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuMemFreeHost == NULL:
         with gil:
             raise RuntimeError('Function "cuMemFreeHost" not found')
-    err = (<CUresult (*)(void*) nogil> __cuMemFreeHost)(p)
+    err = (<CUresult (*)(void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemFreeHost)(p)
     return err
 {{endif}}
 
@@ -8385,7 +8385,7 @@ cdef CUresult _cuMemHostAlloc(void** pp, size_t bytesize, unsigned int Flags) ex
     if __cuMemHostAlloc == NULL:
         with gil:
             raise RuntimeError('Function "cuMemHostAlloc" not found')
-    err = (<CUresult (*)(void**, size_t, unsigned int) nogil> __cuMemHostAlloc)(pp, bytesize, Flags)
+    err = (<CUresult (*)(void**, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemHostAlloc)(pp, bytesize, Flags)
     return err
 {{endif}}
 
@@ -8397,7 +8397,7 @@ cdef CUresult _cuMemHostGetDevicePointer_v2(CUdeviceptr* pdptr, void* p, unsigne
     if __cuMemHostGetDevicePointer_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemHostGetDevicePointer_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, void*, unsigned int) nogil> __cuMemHostGetDevicePointer_v2)(pdptr, p, Flags)
+    err = (<CUresult (*)(CUdeviceptr*, void*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemHostGetDevicePointer_v2)(pdptr, p, Flags)
     return err
 {{endif}}
 
@@ -8409,7 +8409,7 @@ cdef CUresult _cuMemHostGetFlags(unsigned int* pFlags, void* p) except ?CUDA_ERR
     if __cuMemHostGetFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuMemHostGetFlags" not found')
-    err = (<CUresult (*)(unsigned int*, void*) nogil> __cuMemHostGetFlags)(pFlags, p)
+    err = (<CUresult (*)(unsigned int*, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemHostGetFlags)(pFlags, p)
     return err
 {{endif}}
 
@@ -8421,7 +8421,7 @@ cdef CUresult _cuMemAllocManaged(CUdeviceptr* dptr, size_t bytesize, unsigned in
     if __cuMemAllocManaged == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAllocManaged" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t, unsigned int) nogil> __cuMemAllocManaged)(dptr, bytesize, flags)
+    err = (<CUresult (*)(CUdeviceptr*, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAllocManaged)(dptr, bytesize, flags)
     return err
 {{endif}}
 
@@ -8433,7 +8433,7 @@ cdef CUresult _cuDeviceGetByPCIBusId(CUdevice* dev, const char* pciBusId) except
     if __cuDeviceGetByPCIBusId == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetByPCIBusId" not found')
-    err = (<CUresult (*)(CUdevice*, const char*) nogil> __cuDeviceGetByPCIBusId)(dev, pciBusId)
+    err = (<CUresult (*)(CUdevice*, const char*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetByPCIBusId)(dev, pciBusId)
     return err
 {{endif}}
 
@@ -8445,7 +8445,7 @@ cdef CUresult _cuDeviceGetPCIBusId(char* pciBusId, int length, CUdevice dev) exc
     if __cuDeviceGetPCIBusId == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetPCIBusId" not found')
-    err = (<CUresult (*)(char*, int, CUdevice) nogil> __cuDeviceGetPCIBusId)(pciBusId, length, dev)
+    err = (<CUresult (*)(char*, int, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetPCIBusId)(pciBusId, length, dev)
     return err
 {{endif}}
 
@@ -8457,7 +8457,7 @@ cdef CUresult _cuIpcGetEventHandle(CUipcEventHandle* pHandle, CUevent event) exc
     if __cuIpcGetEventHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuIpcGetEventHandle" not found')
-    err = (<CUresult (*)(CUipcEventHandle*, CUevent) nogil> __cuIpcGetEventHandle)(pHandle, event)
+    err = (<CUresult (*)(CUipcEventHandle*, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuIpcGetEventHandle)(pHandle, event)
     return err
 {{endif}}
 
@@ -8469,7 +8469,7 @@ cdef CUresult _cuIpcOpenEventHandle(CUevent* phEvent, CUipcEventHandle handle) e
     if __cuIpcOpenEventHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuIpcOpenEventHandle" not found')
-    err = (<CUresult (*)(CUevent*, CUipcEventHandle) nogil> __cuIpcOpenEventHandle)(phEvent, handle)
+    err = (<CUresult (*)(CUevent*, CUipcEventHandle) except ?CUDA_ERROR_NOT_FOUND nogil> __cuIpcOpenEventHandle)(phEvent, handle)
     return err
 {{endif}}
 
@@ -8481,7 +8481,7 @@ cdef CUresult _cuIpcGetMemHandle(CUipcMemHandle* pHandle, CUdeviceptr dptr) exce
     if __cuIpcGetMemHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuIpcGetMemHandle" not found')
-    err = (<CUresult (*)(CUipcMemHandle*, CUdeviceptr) nogil> __cuIpcGetMemHandle)(pHandle, dptr)
+    err = (<CUresult (*)(CUipcMemHandle*, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuIpcGetMemHandle)(pHandle, dptr)
     return err
 {{endif}}
 
@@ -8493,7 +8493,7 @@ cdef CUresult _cuIpcOpenMemHandle_v2(CUdeviceptr* pdptr, CUipcMemHandle handle,
     if __cuIpcOpenMemHandle_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuIpcOpenMemHandle_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, CUipcMemHandle, unsigned int) nogil> __cuIpcOpenMemHandle_v2)(pdptr, handle, Flags)
+    err = (<CUresult (*)(CUdeviceptr*, CUipcMemHandle, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuIpcOpenMemHandle_v2)(pdptr, handle, Flags)
     return err
 {{endif}}
 
@@ -8505,7 +8505,7 @@ cdef CUresult _cuIpcCloseMemHandle(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUN
     if __cuIpcCloseMemHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuIpcCloseMemHandle" not found')
-    err = (<CUresult (*)(CUdeviceptr) nogil> __cuIpcCloseMemHandle)(dptr)
+    err = (<CUresult (*)(CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuIpcCloseMemHandle)(dptr)
     return err
 {{endif}}
 
@@ -8517,7 +8517,7 @@ cdef CUresult _cuMemHostRegister_v2(void* p, size_t bytesize, unsigned int Flags
     if __cuMemHostRegister_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemHostRegister_v2" not found')
-    err = (<CUresult (*)(void*, size_t, unsigned int) nogil> __cuMemHostRegister_v2)(p, bytesize, Flags)
+    err = (<CUresult (*)(void*, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemHostRegister_v2)(p, bytesize, Flags)
     return err
 {{endif}}
 
@@ -8529,7 +8529,7 @@ cdef CUresult _cuMemHostUnregister(void* p) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuMemHostUnregister == NULL:
         with gil:
             raise RuntimeError('Function "cuMemHostUnregister" not found')
-    err = (<CUresult (*)(void*) nogil> __cuMemHostUnregister)(p)
+    err = (<CUresult (*)(void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemHostUnregister)(p)
     return err
 {{endif}}
 
@@ -8541,7 +8541,7 @@ cdef CUresult _cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) exce
     if __cuMemcpy == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t) nogil> __cuMemcpy)(dst, src, ByteCount)
+    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy)(dst, src, ByteCount)
     return err
 {{endif}}
 
@@ -8553,7 +8553,7 @@ cdef CUresult _cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdevic
     if __cuMemcpyPeer == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyPeer" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) nogil> __cuMemcpyPeer)(dstDevice, dstContext, srcDevice, srcContext, ByteCount)
+    err = (<CUresult (*)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyPeer)(dstDevice, dstContext, srcDevice, srcContext, ByteCount)
     return err
 {{endif}}
 
@@ -8565,7 +8565,7 @@ cdef CUresult _cuMemcpyHtoD_v2(CUdeviceptr dstDevice, const void* srcHost, size_
     if __cuMemcpyHtoD_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyHtoD_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, const void*, size_t) nogil> __cuMemcpyHtoD_v2)(dstDevice, srcHost, ByteCount)
+    err = (<CUresult (*)(CUdeviceptr, const void*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyHtoD_v2)(dstDevice, srcHost, ByteCount)
     return err
 {{endif}}
 
@@ -8577,7 +8577,7 @@ cdef CUresult _cuMemcpyDtoH_v2(void* dstHost, CUdeviceptr srcDevice, size_t Byte
     if __cuMemcpyDtoH_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyDtoH_v2" not found')
-    err = (<CUresult (*)(void*, CUdeviceptr, size_t) nogil> __cuMemcpyDtoH_v2)(dstHost, srcDevice, ByteCount)
+    err = (<CUresult (*)(void*, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyDtoH_v2)(dstHost, srcDevice, ByteCount)
     return err
 {{endif}}
 
@@ -8589,7 +8589,7 @@ cdef CUresult _cuMemcpyDtoD_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice, siz
     if __cuMemcpyDtoD_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyDtoD_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t) nogil> __cuMemcpyDtoD_v2)(dstDevice, srcDevice, ByteCount)
+    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyDtoD_v2)(dstDevice, srcDevice, ByteCount)
     return err
 {{endif}}
 
@@ -8601,7 +8601,7 @@ cdef CUresult _cuMemcpyDtoA_v2(CUarray dstArray, size_t dstOffset, CUdeviceptr s
     if __cuMemcpyDtoA_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyDtoA_v2" not found')
-    err = (<CUresult (*)(CUarray, size_t, CUdeviceptr, size_t) nogil> __cuMemcpyDtoA_v2)(dstArray, dstOffset, srcDevice, ByteCount)
+    err = (<CUresult (*)(CUarray, size_t, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyDtoA_v2)(dstArray, dstOffset, srcDevice, ByteCount)
     return err
 {{endif}}
 
@@ -8613,7 +8613,7 @@ cdef CUresult _cuMemcpyAtoD_v2(CUdeviceptr dstDevice, CUarray srcArray, size_t s
     if __cuMemcpyAtoD_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyAtoD_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUarray, size_t, size_t) nogil> __cuMemcpyAtoD_v2)(dstDevice, srcArray, srcOffset, ByteCount)
+    err = (<CUresult (*)(CUdeviceptr, CUarray, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyAtoD_v2)(dstDevice, srcArray, srcOffset, ByteCount)
     return err
 {{endif}}
 
@@ -8625,7 +8625,7 @@ cdef CUresult _cuMemcpyHtoA_v2(CUarray dstArray, size_t dstOffset, const void* s
     if __cuMemcpyHtoA_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyHtoA_v2" not found')
-    err = (<CUresult (*)(CUarray, size_t, const void*, size_t) nogil> __cuMemcpyHtoA_v2)(dstArray, dstOffset, srcHost, ByteCount)
+    err = (<CUresult (*)(CUarray, size_t, const void*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyHtoA_v2)(dstArray, dstOffset, srcHost, ByteCount)
     return err
 {{endif}}
 
@@ -8637,7 +8637,7 @@ cdef CUresult _cuMemcpyAtoH_v2(void* dstHost, CUarray srcArray, size_t srcOffset
     if __cuMemcpyAtoH_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyAtoH_v2" not found')
-    err = (<CUresult (*)(void*, CUarray, size_t, size_t) nogil> __cuMemcpyAtoH_v2)(dstHost, srcArray, srcOffset, ByteCount)
+    err = (<CUresult (*)(void*, CUarray, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyAtoH_v2)(dstHost, srcArray, srcOffset, ByteCount)
     return err
 {{endif}}
 
@@ -8649,7 +8649,7 @@ cdef CUresult _cuMemcpyAtoA_v2(CUarray dstArray, size_t dstOffset, CUarray srcAr
     if __cuMemcpyAtoA_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyAtoA_v2" not found')
-    err = (<CUresult (*)(CUarray, size_t, CUarray, size_t, size_t) nogil> __cuMemcpyAtoA_v2)(dstArray, dstOffset, srcArray, srcOffset, ByteCount)
+    err = (<CUresult (*)(CUarray, size_t, CUarray, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyAtoA_v2)(dstArray, dstOffset, srcArray, srcOffset, ByteCount)
     return err
 {{endif}}
 
@@ -8661,7 +8661,7 @@ cdef CUresult _cuMemcpy2D_v2(const CUDA_MEMCPY2D* pCopy) except ?CUDA_ERROR_NOT_
     if __cuMemcpy2D_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy2D_v2" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY2D*) nogil> __cuMemcpy2D_v2)(pCopy)
+    err = (<CUresult (*)(const CUDA_MEMCPY2D*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy2D_v2)(pCopy)
     return err
 {{endif}}
 
@@ -8673,7 +8673,7 @@ cdef CUresult _cuMemcpy2DUnaligned_v2(const CUDA_MEMCPY2D* pCopy) except ?CUDA_E
     if __cuMemcpy2DUnaligned_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy2DUnaligned_v2" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY2D*) nogil> __cuMemcpy2DUnaligned_v2)(pCopy)
+    err = (<CUresult (*)(const CUDA_MEMCPY2D*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy2DUnaligned_v2)(pCopy)
     return err
 {{endif}}
 
@@ -8685,7 +8685,7 @@ cdef CUresult _cuMemcpy3D_v2(const CUDA_MEMCPY3D* pCopy) except ?CUDA_ERROR_NOT_
     if __cuMemcpy3D_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy3D_v2" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY3D*) nogil> __cuMemcpy3D_v2)(pCopy)
+    err = (<CUresult (*)(const CUDA_MEMCPY3D*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy3D_v2)(pCopy)
     return err
 {{endif}}
 
@@ -8697,7 +8697,7 @@ cdef CUresult _cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER* pCopy) except ?CUDA_ERRO
     if __cuMemcpy3DPeer == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy3DPeer" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY3D_PEER*) nogil> __cuMemcpy3DPeer)(pCopy)
+    err = (<CUresult (*)(const CUDA_MEMCPY3D_PEER*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy3DPeer)(pCopy)
     return err
 {{endif}}
 
@@ -8709,7 +8709,7 @@ cdef CUresult _cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount,
     if __cuMemcpyAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t, CUstream) nogil> __cuMemcpyAsync)(dst, src, ByteCount, hStream)
+    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyAsync)(dst, src, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8721,7 +8721,7 @@ cdef CUresult _cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CU
     if __cuMemcpyPeerAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyPeerAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) nogil> __cuMemcpyPeerAsync)(dstDevice, dstContext, srcDevice, srcContext, ByteCount, hStream)
+    err = (<CUresult (*)(CUdeviceptr, CUcontext, CUdeviceptr, CUcontext, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyPeerAsync)(dstDevice, dstContext, srcDevice, srcContext, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8733,7 +8733,7 @@ cdef CUresult _cuMemcpyHtoDAsync_v2(CUdeviceptr dstDevice, const void* srcHost,
     if __cuMemcpyHtoDAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyHtoDAsync_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, const void*, size_t, CUstream) nogil> __cuMemcpyHtoDAsync_v2)(dstDevice, srcHost, ByteCount, hStream)
+    err = (<CUresult (*)(CUdeviceptr, const void*, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyHtoDAsync_v2)(dstDevice, srcHost, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8745,7 +8745,7 @@ cdef CUresult _cuMemcpyDtoHAsync_v2(void* dstHost, CUdeviceptr srcDevice, size_t
     if __cuMemcpyDtoHAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyDtoHAsync_v2" not found')
-    err = (<CUresult (*)(void*, CUdeviceptr, size_t, CUstream) nogil> __cuMemcpyDtoHAsync_v2)(dstHost, srcDevice, ByteCount, hStream)
+    err = (<CUresult (*)(void*, CUdeviceptr, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyDtoHAsync_v2)(dstHost, srcDevice, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8757,7 +8757,7 @@ cdef CUresult _cuMemcpyDtoDAsync_v2(CUdeviceptr dstDevice, CUdeviceptr srcDevice
     if __cuMemcpyDtoDAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyDtoDAsync_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t, CUstream) nogil> __cuMemcpyDtoDAsync_v2)(dstDevice, srcDevice, ByteCount, hStream)
+    err = (<CUresult (*)(CUdeviceptr, CUdeviceptr, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyDtoDAsync_v2)(dstDevice, srcDevice, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8769,7 +8769,7 @@ cdef CUresult _cuMemcpyHtoAAsync_v2(CUarray dstArray, size_t dstOffset, const vo
     if __cuMemcpyHtoAAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyHtoAAsync_v2" not found')
-    err = (<CUresult (*)(CUarray, size_t, const void*, size_t, CUstream) nogil> __cuMemcpyHtoAAsync_v2)(dstArray, dstOffset, srcHost, ByteCount, hStream)
+    err = (<CUresult (*)(CUarray, size_t, const void*, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyHtoAAsync_v2)(dstArray, dstOffset, srcHost, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8781,7 +8781,7 @@ cdef CUresult _cuMemcpyAtoHAsync_v2(void* dstHost, CUarray srcArray, size_t srcO
     if __cuMemcpyAtoHAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpyAtoHAsync_v2" not found')
-    err = (<CUresult (*)(void*, CUarray, size_t, size_t, CUstream) nogil> __cuMemcpyAtoHAsync_v2)(dstHost, srcArray, srcOffset, ByteCount, hStream)
+    err = (<CUresult (*)(void*, CUarray, size_t, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpyAtoHAsync_v2)(dstHost, srcArray, srcOffset, ByteCount, hStream)
     return err
 {{endif}}
 
@@ -8793,7 +8793,7 @@ cdef CUresult _cuMemcpy2DAsync_v2(const CUDA_MEMCPY2D* pCopy, CUstream hStream)
     if __cuMemcpy2DAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy2DAsync_v2" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY2D*, CUstream) nogil> __cuMemcpy2DAsync_v2)(pCopy, hStream)
+    err = (<CUresult (*)(const CUDA_MEMCPY2D*, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy2DAsync_v2)(pCopy, hStream)
     return err
 {{endif}}
 
@@ -8805,7 +8805,7 @@ cdef CUresult _cuMemcpy3DAsync_v2(const CUDA_MEMCPY3D* pCopy, CUstream hStream)
     if __cuMemcpy3DAsync_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy3DAsync_v2" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY3D*, CUstream) nogil> __cuMemcpy3DAsync_v2)(pCopy, hStream)
+    err = (<CUresult (*)(const CUDA_MEMCPY3D*, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy3DAsync_v2)(pCopy, hStream)
     return err
 {{endif}}
 
@@ -8817,7 +8817,7 @@ cdef CUresult _cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER* pCopy, CUstream hSt
     if __cuMemcpy3DPeerAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemcpy3DPeerAsync" not found')
-    err = (<CUresult (*)(const CUDA_MEMCPY3D_PEER*, CUstream) nogil> __cuMemcpy3DPeerAsync)(pCopy, hStream)
+    err = (<CUresult (*)(const CUDA_MEMCPY3D_PEER*, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemcpy3DPeerAsync)(pCopy, hStream)
     return err
 {{endif}}
 
@@ -8829,7 +8829,7 @@ cdef CUresult _cuMemsetD8_v2(CUdeviceptr dstDevice, unsigned char uc, size_t N)
     if __cuMemsetD8_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD8_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned char, size_t) nogil> __cuMemsetD8_v2)(dstDevice, uc, N)
+    err = (<CUresult (*)(CUdeviceptr, unsigned char, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD8_v2)(dstDevice, uc, N)
     return err
 {{endif}}
 
@@ -8841,7 +8841,7 @@ cdef CUresult _cuMemsetD16_v2(CUdeviceptr dstDevice, unsigned short us, size_t N
     if __cuMemsetD16_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD16_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned short, size_t) nogil> __cuMemsetD16_v2)(dstDevice, us, N)
+    err = (<CUresult (*)(CUdeviceptr, unsigned short, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD16_v2)(dstDevice, us, N)
     return err
 {{endif}}
 
@@ -8853,7 +8853,7 @@ cdef CUresult _cuMemsetD32_v2(CUdeviceptr dstDevice, unsigned int ui, size_t N)
     if __cuMemsetD32_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD32_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned int, size_t) nogil> __cuMemsetD32_v2)(dstDevice, ui, N)
+    err = (<CUresult (*)(CUdeviceptr, unsigned int, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD32_v2)(dstDevice, ui, N)
     return err
 {{endif}}
 
@@ -8865,7 +8865,7 @@ cdef CUresult _cuMemsetD2D8_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned
     if __cuMemsetD2D8_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D8_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned char, size_t, size_t) nogil> __cuMemsetD2D8_v2)(dstDevice, dstPitch, uc, Width, Height)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned char, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D8_v2)(dstDevice, dstPitch, uc, Width, Height)
     return err
 {{endif}}
 
@@ -8877,7 +8877,7 @@ cdef CUresult _cuMemsetD2D16_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned
     if __cuMemsetD2D16_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D16_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned short, size_t, size_t) nogil> __cuMemsetD2D16_v2)(dstDevice, dstPitch, us, Width, Height)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned short, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D16_v2)(dstDevice, dstPitch, us, Width, Height)
     return err
 {{endif}}
 
@@ -8889,7 +8889,7 @@ cdef CUresult _cuMemsetD2D32_v2(CUdeviceptr dstDevice, size_t dstPitch, unsigned
     if __cuMemsetD2D32_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D32_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned int, size_t, size_t) nogil> __cuMemsetD2D32_v2)(dstDevice, dstPitch, ui, Width, Height)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned int, size_t, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D32_v2)(dstDevice, dstPitch, ui, Width, Height)
     return err
 {{endif}}
 
@@ -8901,7 +8901,7 @@ cdef CUresult _cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N
     if __cuMemsetD8Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD8Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned char, size_t, CUstream) nogil> __cuMemsetD8Async)(dstDevice, uc, N, hStream)
+    err = (<CUresult (*)(CUdeviceptr, unsigned char, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD8Async)(dstDevice, uc, N, hStream)
     return err
 {{endif}}
 
@@ -8913,7 +8913,7 @@ cdef CUresult _cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t
     if __cuMemsetD16Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD16Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned short, size_t, CUstream) nogil> __cuMemsetD16Async)(dstDevice, us, N, hStream)
+    err = (<CUresult (*)(CUdeviceptr, unsigned short, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD16Async)(dstDevice, us, N, hStream)
     return err
 {{endif}}
 
@@ -8925,7 +8925,7 @@ cdef CUresult _cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N
     if __cuMemsetD32Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD32Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, unsigned int, size_t, CUstream) nogil> __cuMemsetD32Async)(dstDevice, ui, N, hStream)
+    err = (<CUresult (*)(CUdeviceptr, unsigned int, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD32Async)(dstDevice, ui, N, hStream)
     return err
 {{endif}}
 
@@ -8937,7 +8937,7 @@ cdef CUresult _cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigne
     if __cuMemsetD2D8Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D8Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) nogil> __cuMemsetD2D8Async)(dstDevice, dstPitch, uc, Width, Height, hStream)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned char, size_t, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D8Async)(dstDevice, dstPitch, uc, Width, Height, hStream)
     return err
 {{endif}}
 
@@ -8949,7 +8949,7 @@ cdef CUresult _cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsign
     if __cuMemsetD2D16Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D16Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) nogil> __cuMemsetD2D16Async)(dstDevice, dstPitch, us, Width, Height, hStream)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned short, size_t, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D16Async)(dstDevice, dstPitch, us, Width, Height, hStream)
     return err
 {{endif}}
 
@@ -8961,7 +8961,7 @@ cdef CUresult _cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsign
     if __cuMemsetD2D32Async == NULL:
         with gil:
             raise RuntimeError('Function "cuMemsetD2D32Async" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) nogil> __cuMemsetD2D32Async)(dstDevice, dstPitch, ui, Width, Height, hStream)
+    err = (<CUresult (*)(CUdeviceptr, size_t, unsigned int, size_t, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemsetD2D32Async)(dstDevice, dstPitch, ui, Width, Height, hStream)
     return err
 {{endif}}
 
@@ -8973,7 +8973,7 @@ cdef CUresult _cuArrayCreate_v2(CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* p
     if __cuArrayCreate_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayCreate_v2" not found')
-    err = (<CUresult (*)(CUarray*, const CUDA_ARRAY_DESCRIPTOR*) nogil> __cuArrayCreate_v2)(pHandle, pAllocateArray)
+    err = (<CUresult (*)(CUarray*, const CUDA_ARRAY_DESCRIPTOR*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayCreate_v2)(pHandle, pAllocateArray)
     return err
 {{endif}}
 
@@ -8985,7 +8985,7 @@ cdef CUresult _cuArrayGetDescriptor_v2(CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor,
     if __cuArrayGetDescriptor_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayGetDescriptor_v2" not found')
-    err = (<CUresult (*)(CUDA_ARRAY_DESCRIPTOR*, CUarray) nogil> __cuArrayGetDescriptor_v2)(pArrayDescriptor, hArray)
+    err = (<CUresult (*)(CUDA_ARRAY_DESCRIPTOR*, CUarray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayGetDescriptor_v2)(pArrayDescriptor, hArray)
     return err
 {{endif}}
 
@@ -8997,7 +8997,7 @@ cdef CUresult _cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES* sparsePr
     if __cuArrayGetSparseProperties == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayGetSparseProperties" not found')
-    err = (<CUresult (*)(CUDA_ARRAY_SPARSE_PROPERTIES*, CUarray) nogil> __cuArrayGetSparseProperties)(sparseProperties, array)
+    err = (<CUresult (*)(CUDA_ARRAY_SPARSE_PROPERTIES*, CUarray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayGetSparseProperties)(sparseProperties, array)
     return err
 {{endif}}
 
@@ -9009,7 +9009,7 @@ cdef CUresult _cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES*
     if __cuMipmappedArrayGetSparseProperties == NULL:
         with gil:
             raise RuntimeError('Function "cuMipmappedArrayGetSparseProperties" not found')
-    err = (<CUresult (*)(CUDA_ARRAY_SPARSE_PROPERTIES*, CUmipmappedArray) nogil> __cuMipmappedArrayGetSparseProperties)(sparseProperties, mipmap)
+    err = (<CUresult (*)(CUDA_ARRAY_SPARSE_PROPERTIES*, CUmipmappedArray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMipmappedArrayGetSparseProperties)(sparseProperties, mipmap)
     return err
 {{endif}}
 
@@ -9021,7 +9021,7 @@ cdef CUresult _cuArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS* memo
     if __cuArrayGetMemoryRequirements == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayGetMemoryRequirements" not found')
-    err = (<CUresult (*)(CUDA_ARRAY_MEMORY_REQUIREMENTS*, CUarray, CUdevice) nogil> __cuArrayGetMemoryRequirements)(memoryRequirements, array, device)
+    err = (<CUresult (*)(CUDA_ARRAY_MEMORY_REQUIREMENTS*, CUarray, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayGetMemoryRequirements)(memoryRequirements, array, device)
     return err
 {{endif}}
 
@@ -9033,7 +9033,7 @@ cdef CUresult _cuMipmappedArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREME
     if __cuMipmappedArrayGetMemoryRequirements == NULL:
         with gil:
             raise RuntimeError('Function "cuMipmappedArrayGetMemoryRequirements" not found')
-    err = (<CUresult (*)(CUDA_ARRAY_MEMORY_REQUIREMENTS*, CUmipmappedArray, CUdevice) nogil> __cuMipmappedArrayGetMemoryRequirements)(memoryRequirements, mipmap, device)
+    err = (<CUresult (*)(CUDA_ARRAY_MEMORY_REQUIREMENTS*, CUmipmappedArray, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMipmappedArrayGetMemoryRequirements)(memoryRequirements, mipmap, device)
     return err
 {{endif}}
 
@@ -9045,7 +9045,7 @@ cdef CUresult _cuArrayGetPlane(CUarray* pPlaneArray, CUarray hArray, unsigned in
     if __cuArrayGetPlane == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayGetPlane" not found')
-    err = (<CUresult (*)(CUarray*, CUarray, unsigned int) nogil> __cuArrayGetPlane)(pPlaneArray, hArray, planeIdx)
+    err = (<CUresult (*)(CUarray*, CUarray, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayGetPlane)(pPlaneArray, hArray, planeIdx)
     return err
 {{endif}}
 
@@ -9057,7 +9057,7 @@ cdef CUresult _cuArrayDestroy(CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil
     if __cuArrayDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuArrayDestroy" not found')
-    err = (<CUresult (*)(CUarray) nogil> __cuArrayDestroy)(hArray)
+    err = (<CUresult (*)(CUarray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArrayDestroy)(hArray)
     return err
 {{endif}}
 
@@ -9069,7 +9069,7 @@ cdef CUresult _cuArray3DCreate_v2(CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTO
     if __cuArray3DCreate_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuArray3DCreate_v2" not found')
-    err = (<CUresult (*)(CUarray*, const CUDA_ARRAY3D_DESCRIPTOR*) nogil> __cuArray3DCreate_v2)(pHandle, pAllocateArray)
+    err = (<CUresult (*)(CUarray*, const CUDA_ARRAY3D_DESCRIPTOR*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArray3DCreate_v2)(pHandle, pAllocateArray)
     return err
 {{endif}}
 
@@ -9081,7 +9081,7 @@ cdef CUresult _cuArray3DGetDescriptor_v2(CUDA_ARRAY3D_DESCRIPTOR* pArrayDescript
     if __cuArray3DGetDescriptor_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuArray3DGetDescriptor_v2" not found')
-    err = (<CUresult (*)(CUDA_ARRAY3D_DESCRIPTOR*, CUarray) nogil> __cuArray3DGetDescriptor_v2)(pArrayDescriptor, hArray)
+    err = (<CUresult (*)(CUDA_ARRAY3D_DESCRIPTOR*, CUarray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuArray3DGetDescriptor_v2)(pArrayDescriptor, hArray)
     return err
 {{endif}}
 
@@ -9093,7 +9093,7 @@ cdef CUresult _cuMipmappedArrayCreate(CUmipmappedArray* pHandle, const CUDA_ARRA
     if __cuMipmappedArrayCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuMipmappedArrayCreate" not found')
-    err = (<CUresult (*)(CUmipmappedArray*, const CUDA_ARRAY3D_DESCRIPTOR*, unsigned int) nogil> __cuMipmappedArrayCreate)(pHandle, pMipmappedArrayDesc, numMipmapLevels)
+    err = (<CUresult (*)(CUmipmappedArray*, const CUDA_ARRAY3D_DESCRIPTOR*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMipmappedArrayCreate)(pHandle, pMipmappedArrayDesc, numMipmapLevels)
     return err
 {{endif}}
 
@@ -9105,7 +9105,7 @@ cdef CUresult _cuMipmappedArrayGetLevel(CUarray* pLevelArray, CUmipmappedArray h
     if __cuMipmappedArrayGetLevel == NULL:
         with gil:
             raise RuntimeError('Function "cuMipmappedArrayGetLevel" not found')
-    err = (<CUresult (*)(CUarray*, CUmipmappedArray, unsigned int) nogil> __cuMipmappedArrayGetLevel)(pLevelArray, hMipmappedArray, level)
+    err = (<CUresult (*)(CUarray*, CUmipmappedArray, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMipmappedArrayGetLevel)(pLevelArray, hMipmappedArray, level)
     return err
 {{endif}}
 
@@ -9117,7 +9117,7 @@ cdef CUresult _cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) except
     if __cuMipmappedArrayDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuMipmappedArrayDestroy" not found')
-    err = (<CUresult (*)(CUmipmappedArray) nogil> __cuMipmappedArrayDestroy)(hMipmappedArray)
+    err = (<CUresult (*)(CUmipmappedArray) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMipmappedArrayDestroy)(hMipmappedArray)
     return err
 {{endif}}
 
@@ -9129,7 +9129,7 @@ cdef CUresult _cuMemGetHandleForAddressRange(void* handle, CUdeviceptr dptr, siz
     if __cuMemGetHandleForAddressRange == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetHandleForAddressRange" not found')
-    err = (<CUresult (*)(void*, CUdeviceptr, size_t, CUmemRangeHandleType, unsigned long long) nogil> __cuMemGetHandleForAddressRange)(handle, dptr, size, handleType, flags)
+    err = (<CUresult (*)(void*, CUdeviceptr, size_t, CUmemRangeHandleType, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetHandleForAddressRange)(handle, dptr, size, handleType, flags)
     return err
 {{endif}}
 
@@ -9141,7 +9141,7 @@ cdef CUresult _cuMemAddressReserve(CUdeviceptr* ptr, size_t size, size_t alignme
     if __cuMemAddressReserve == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAddressReserve" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t, size_t, CUdeviceptr, unsigned long long) nogil> __cuMemAddressReserve)(ptr, size, alignment, addr, flags)
+    err = (<CUresult (*)(CUdeviceptr*, size_t, size_t, CUdeviceptr, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAddressReserve)(ptr, size, alignment, addr, flags)
     return err
 {{endif}}
 
@@ -9153,7 +9153,7 @@ cdef CUresult _cuMemAddressFree(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR
     if __cuMemAddressFree == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAddressFree" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t) nogil> __cuMemAddressFree)(ptr, size)
+    err = (<CUresult (*)(CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAddressFree)(ptr, size)
     return err
 {{endif}}
 
@@ -9165,7 +9165,7 @@ cdef CUresult _cuMemCreate(CUmemGenericAllocationHandle* handle, size_t size, co
     if __cuMemCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuMemCreate" not found')
-    err = (<CUresult (*)(CUmemGenericAllocationHandle*, size_t, const CUmemAllocationProp*, unsigned long long) nogil> __cuMemCreate)(handle, size, prop, flags)
+    err = (<CUresult (*)(CUmemGenericAllocationHandle*, size_t, const CUmemAllocationProp*, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemCreate)(handle, size, prop, flags)
     return err
 {{endif}}
 
@@ -9177,7 +9177,7 @@ cdef CUresult _cuMemRelease(CUmemGenericAllocationHandle handle) except ?CUDA_ER
     if __cuMemRelease == NULL:
         with gil:
             raise RuntimeError('Function "cuMemRelease" not found')
-    err = (<CUresult (*)(CUmemGenericAllocationHandle) nogil> __cuMemRelease)(handle)
+    err = (<CUresult (*)(CUmemGenericAllocationHandle) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemRelease)(handle)
     return err
 {{endif}}
 
@@ -9189,7 +9189,7 @@ cdef CUresult _cuMemMap(CUdeviceptr ptr, size_t size, size_t offset, CUmemGeneri
     if __cuMemMap == NULL:
         with gil:
             raise RuntimeError('Function "cuMemMap" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long) nogil> __cuMemMap)(ptr, size, offset, handle, flags)
+    err = (<CUresult (*)(CUdeviceptr, size_t, size_t, CUmemGenericAllocationHandle, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemMap)(ptr, size, offset, handle, flags)
     return err
 {{endif}}
 
@@ -9201,7 +9201,7 @@ cdef CUresult _cuMemMapArrayAsync(CUarrayMapInfo* mapInfoList, unsigned int coun
     if __cuMemMapArrayAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemMapArrayAsync" not found')
-    err = (<CUresult (*)(CUarrayMapInfo*, unsigned int, CUstream) nogil> __cuMemMapArrayAsync)(mapInfoList, count, hStream)
+    err = (<CUresult (*)(CUarrayMapInfo*, unsigned int, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemMapArrayAsync)(mapInfoList, count, hStream)
     return err
 {{endif}}
 
@@ -9213,7 +9213,7 @@ cdef CUresult _cuMemUnmap(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR_NOT_F
     if __cuMemUnmap == NULL:
         with gil:
             raise RuntimeError('Function "cuMemUnmap" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t) nogil> __cuMemUnmap)(ptr, size)
+    err = (<CUresult (*)(CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemUnmap)(ptr, size)
     return err
 {{endif}}
 
@@ -9225,7 +9225,7 @@ cdef CUresult _cuMemSetAccess(CUdeviceptr ptr, size_t size, const CUmemAccessDes
     if __cuMemSetAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuMemSetAccess" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, const CUmemAccessDesc*, size_t) nogil> __cuMemSetAccess)(ptr, size, desc, count)
+    err = (<CUresult (*)(CUdeviceptr, size_t, const CUmemAccessDesc*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemSetAccess)(ptr, size, desc, count)
     return err
 {{endif}}
 
@@ -9237,7 +9237,7 @@ cdef CUresult _cuMemGetAccess(unsigned long long* flags, const CUmemLocation* lo
     if __cuMemGetAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetAccess" not found')
-    err = (<CUresult (*)(unsigned long long*, const CUmemLocation*, CUdeviceptr) nogil> __cuMemGetAccess)(flags, location, ptr)
+    err = (<CUresult (*)(unsigned long long*, const CUmemLocation*, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetAccess)(flags, location, ptr)
     return err
 {{endif}}
 
@@ -9249,7 +9249,7 @@ cdef CUresult _cuMemExportToShareableHandle(void* shareableHandle, CUmemGenericA
     if __cuMemExportToShareableHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemExportToShareableHandle" not found')
-    err = (<CUresult (*)(void*, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long) nogil> __cuMemExportToShareableHandle)(shareableHandle, handle, handleType, flags)
+    err = (<CUresult (*)(void*, CUmemGenericAllocationHandle, CUmemAllocationHandleType, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemExportToShareableHandle)(shareableHandle, handle, handleType, flags)
     return err
 {{endif}}
 
@@ -9261,7 +9261,7 @@ cdef CUresult _cuMemImportFromShareableHandle(CUmemGenericAllocationHandle* hand
     if __cuMemImportFromShareableHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemImportFromShareableHandle" not found')
-    err = (<CUresult (*)(CUmemGenericAllocationHandle*, void*, CUmemAllocationHandleType) nogil> __cuMemImportFromShareableHandle)(handle, osHandle, shHandleType)
+    err = (<CUresult (*)(CUmemGenericAllocationHandle*, void*, CUmemAllocationHandleType) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemImportFromShareableHandle)(handle, osHandle, shHandleType)
     return err
 {{endif}}
 
@@ -9273,7 +9273,7 @@ cdef CUresult _cuMemGetAllocationGranularity(size_t* granularity, const CUmemAll
     if __cuMemGetAllocationGranularity == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetAllocationGranularity" not found')
-    err = (<CUresult (*)(size_t*, const CUmemAllocationProp*, CUmemAllocationGranularity_flags) nogil> __cuMemGetAllocationGranularity)(granularity, prop, option)
+    err = (<CUresult (*)(size_t*, const CUmemAllocationProp*, CUmemAllocationGranularity_flags) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetAllocationGranularity)(granularity, prop, option)
     return err
 {{endif}}
 
@@ -9285,7 +9285,7 @@ cdef CUresult _cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp* prop,
     if __cuMemGetAllocationPropertiesFromHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemGetAllocationPropertiesFromHandle" not found')
-    err = (<CUresult (*)(CUmemAllocationProp*, CUmemGenericAllocationHandle) nogil> __cuMemGetAllocationPropertiesFromHandle)(prop, handle)
+    err = (<CUresult (*)(CUmemAllocationProp*, CUmemGenericAllocationHandle) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemGetAllocationPropertiesFromHandle)(prop, handle)
     return err
 {{endif}}
 
@@ -9297,7 +9297,7 @@ cdef CUresult _cuMemRetainAllocationHandle(CUmemGenericAllocationHandle* handle,
     if __cuMemRetainAllocationHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemRetainAllocationHandle" not found')
-    err = (<CUresult (*)(CUmemGenericAllocationHandle*, void*) nogil> __cuMemRetainAllocationHandle)(handle, addr)
+    err = (<CUresult (*)(CUmemGenericAllocationHandle*, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemRetainAllocationHandle)(handle, addr)
     return err
 {{endif}}
 
@@ -9309,7 +9309,7 @@ cdef CUresult _cuMemFreeAsync(CUdeviceptr dptr, CUstream hStream) except ?CUDA_E
     if __cuMemFreeAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemFreeAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr, CUstream) nogil> __cuMemFreeAsync)(dptr, hStream)
+    err = (<CUresult (*)(CUdeviceptr, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemFreeAsync)(dptr, hStream)
     return err
 {{endif}}
 
@@ -9321,7 +9321,7 @@ cdef CUresult _cuMemAllocAsync(CUdeviceptr* dptr, size_t bytesize, CUstream hStr
     if __cuMemAllocAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAllocAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t, CUstream) nogil> __cuMemAllocAsync)(dptr, bytesize, hStream)
+    err = (<CUresult (*)(CUdeviceptr*, size_t, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAllocAsync)(dptr, bytesize, hStream)
     return err
 {{endif}}
 
@@ -9333,7 +9333,7 @@ cdef CUresult _cuMemPoolTrimTo(CUmemoryPool pool, size_t minBytesToKeep) except
     if __cuMemPoolTrimTo == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolTrimTo" not found')
-    err = (<CUresult (*)(CUmemoryPool, size_t) nogil> __cuMemPoolTrimTo)(pool, minBytesToKeep)
+    err = (<CUresult (*)(CUmemoryPool, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolTrimTo)(pool, minBytesToKeep)
     return err
 {{endif}}
 
@@ -9345,7 +9345,7 @@ cdef CUresult _cuMemPoolSetAttribute(CUmemoryPool pool, CUmemPool_attribute attr
     if __cuMemPoolSetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolSetAttribute" not found')
-    err = (<CUresult (*)(CUmemoryPool, CUmemPool_attribute, void*) nogil> __cuMemPoolSetAttribute)(pool, attr, value)
+    err = (<CUresult (*)(CUmemoryPool, CUmemPool_attribute, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolSetAttribute)(pool, attr, value)
     return err
 {{endif}}
 
@@ -9357,7 +9357,7 @@ cdef CUresult _cuMemPoolGetAttribute(CUmemoryPool pool, CUmemPool_attribute attr
     if __cuMemPoolGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolGetAttribute" not found')
-    err = (<CUresult (*)(CUmemoryPool, CUmemPool_attribute, void*) nogil> __cuMemPoolGetAttribute)(pool, attr, value)
+    err = (<CUresult (*)(CUmemoryPool, CUmemPool_attribute, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolGetAttribute)(pool, attr, value)
     return err
 {{endif}}
 
@@ -9369,7 +9369,7 @@ cdef CUresult _cuMemPoolSetAccess(CUmemoryPool pool, const CUmemAccessDesc* map,
     if __cuMemPoolSetAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolSetAccess" not found')
-    err = (<CUresult (*)(CUmemoryPool, const CUmemAccessDesc*, size_t) nogil> __cuMemPoolSetAccess)(pool, map, count)
+    err = (<CUresult (*)(CUmemoryPool, const CUmemAccessDesc*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolSetAccess)(pool, map, count)
     return err
 {{endif}}
 
@@ -9381,7 +9381,7 @@ cdef CUresult _cuMemPoolGetAccess(CUmemAccess_flags* flags, CUmemoryPool memPool
     if __cuMemPoolGetAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolGetAccess" not found')
-    err = (<CUresult (*)(CUmemAccess_flags*, CUmemoryPool, CUmemLocation*) nogil> __cuMemPoolGetAccess)(flags, memPool, location)
+    err = (<CUresult (*)(CUmemAccess_flags*, CUmemoryPool, CUmemLocation*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolGetAccess)(flags, memPool, location)
     return err
 {{endif}}
 
@@ -9393,7 +9393,7 @@ cdef CUresult _cuMemPoolCreate(CUmemoryPool* pool, const CUmemPoolProps* poolPro
     if __cuMemPoolCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolCreate" not found')
-    err = (<CUresult (*)(CUmemoryPool*, const CUmemPoolProps*) nogil> __cuMemPoolCreate)(pool, poolProps)
+    err = (<CUresult (*)(CUmemoryPool*, const CUmemPoolProps*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolCreate)(pool, poolProps)
     return err
 {{endif}}
 
@@ -9405,7 +9405,7 @@ cdef CUresult _cuMemPoolDestroy(CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND
     if __cuMemPoolDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolDestroy" not found')
-    err = (<CUresult (*)(CUmemoryPool) nogil> __cuMemPoolDestroy)(pool)
+    err = (<CUresult (*)(CUmemoryPool) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolDestroy)(pool)
     return err
 {{endif}}
 
@@ -9417,7 +9417,7 @@ cdef CUresult _cuMemAllocFromPoolAsync(CUdeviceptr* dptr, size_t bytesize, CUmem
     if __cuMemAllocFromPoolAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAllocFromPoolAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t, CUmemoryPool, CUstream) nogil> __cuMemAllocFromPoolAsync)(dptr, bytesize, pool, hStream)
+    err = (<CUresult (*)(CUdeviceptr*, size_t, CUmemoryPool, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAllocFromPoolAsync)(dptr, bytesize, pool, hStream)
     return err
 {{endif}}
 
@@ -9429,7 +9429,7 @@ cdef CUresult _cuMemPoolExportToShareableHandle(void* handle_out, CUmemoryPool p
     if __cuMemPoolExportToShareableHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolExportToShareableHandle" not found')
-    err = (<CUresult (*)(void*, CUmemoryPool, CUmemAllocationHandleType, unsigned long long) nogil> __cuMemPoolExportToShareableHandle)(handle_out, pool, handleType, flags)
+    err = (<CUresult (*)(void*, CUmemoryPool, CUmemAllocationHandleType, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolExportToShareableHandle)(handle_out, pool, handleType, flags)
     return err
 {{endif}}
 
@@ -9441,7 +9441,7 @@ cdef CUresult _cuMemPoolImportFromShareableHandle(CUmemoryPool* pool_out, void*
     if __cuMemPoolImportFromShareableHandle == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolImportFromShareableHandle" not found')
-    err = (<CUresult (*)(CUmemoryPool*, void*, CUmemAllocationHandleType, unsigned long long) nogil> __cuMemPoolImportFromShareableHandle)(pool_out, handle, handleType, flags)
+    err = (<CUresult (*)(CUmemoryPool*, void*, CUmemAllocationHandleType, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolImportFromShareableHandle)(pool_out, handle, handleType, flags)
     return err
 {{endif}}
 
@@ -9453,7 +9453,7 @@ cdef CUresult _cuMemPoolExportPointer(CUmemPoolPtrExportData* shareData_out, CUd
     if __cuMemPoolExportPointer == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolExportPointer" not found')
-    err = (<CUresult (*)(CUmemPoolPtrExportData*, CUdeviceptr) nogil> __cuMemPoolExportPointer)(shareData_out, ptr)
+    err = (<CUresult (*)(CUmemPoolPtrExportData*, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolExportPointer)(shareData_out, ptr)
     return err
 {{endif}}
 
@@ -9465,7 +9465,7 @@ cdef CUresult _cuMemPoolImportPointer(CUdeviceptr* ptr_out, CUmemoryPool pool, C
     if __cuMemPoolImportPointer == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPoolImportPointer" not found')
-    err = (<CUresult (*)(CUdeviceptr*, CUmemoryPool, CUmemPoolPtrExportData*) nogil> __cuMemPoolImportPointer)(ptr_out, pool, shareData)
+    err = (<CUresult (*)(CUdeviceptr*, CUmemoryPool, CUmemPoolPtrExportData*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPoolImportPointer)(ptr_out, pool, shareData)
     return err
 {{endif}}
 
@@ -9477,7 +9477,7 @@ cdef CUresult _cuPointerGetAttribute(void* data, CUpointer_attribute attribute,
     if __cuPointerGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuPointerGetAttribute" not found')
-    err = (<CUresult (*)(void*, CUpointer_attribute, CUdeviceptr) nogil> __cuPointerGetAttribute)(data, attribute, ptr)
+    err = (<CUresult (*)(void*, CUpointer_attribute, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuPointerGetAttribute)(data, attribute, ptr)
     return err
 {{endif}}
 
@@ -9489,7 +9489,7 @@ cdef CUresult _cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dst
     if __cuMemPrefetchAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuMemPrefetchAsync" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, CUdevice, CUstream) nogil> __cuMemPrefetchAsync)(devPtr, count, dstDevice, hStream)
+    err = (<CUresult (*)(CUdeviceptr, size_t, CUdevice, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemPrefetchAsync)(devPtr, count, dstDevice, hStream)
     return err
 {{endif}}
 
@@ -9501,7 +9501,7 @@ cdef CUresult _cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice
     if __cuMemAdvise == NULL:
         with gil:
             raise RuntimeError('Function "cuMemAdvise" not found')
-    err = (<CUresult (*)(CUdeviceptr, size_t, CUmem_advise, CUdevice) nogil> __cuMemAdvise)(devPtr, count, advice, device)
+    err = (<CUresult (*)(CUdeviceptr, size_t, CUmem_advise, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemAdvise)(devPtr, count, advice, device)
     return err
 {{endif}}
 
@@ -9513,7 +9513,7 @@ cdef CUresult _cuMemRangeGetAttribute(void* data, size_t dataSize, CUmem_range_a
     if __cuMemRangeGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuMemRangeGetAttribute" not found')
-    err = (<CUresult (*)(void*, size_t, CUmem_range_attribute, CUdeviceptr, size_t) nogil> __cuMemRangeGetAttribute)(data, dataSize, attribute, devPtr, count)
+    err = (<CUresult (*)(void*, size_t, CUmem_range_attribute, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemRangeGetAttribute)(data, dataSize, attribute, devPtr, count)
     return err
 {{endif}}
 
@@ -9525,7 +9525,7 @@ cdef CUresult _cuMemRangeGetAttributes(void** data, size_t* dataSizes, CUmem_ran
     if __cuMemRangeGetAttributes == NULL:
         with gil:
             raise RuntimeError('Function "cuMemRangeGetAttributes" not found')
-    err = (<CUresult (*)(void**, size_t*, CUmem_range_attribute*, size_t, CUdeviceptr, size_t) nogil> __cuMemRangeGetAttributes)(data, dataSizes, attributes, numAttributes, devPtr, count)
+    err = (<CUresult (*)(void**, size_t*, CUmem_range_attribute*, size_t, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuMemRangeGetAttributes)(data, dataSizes, attributes, numAttributes, devPtr, count)
     return err
 {{endif}}
 
@@ -9537,7 +9537,7 @@ cdef CUresult _cuPointerSetAttribute(const void* value, CUpointer_attribute attr
     if __cuPointerSetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuPointerSetAttribute" not found')
-    err = (<CUresult (*)(const void*, CUpointer_attribute, CUdeviceptr) nogil> __cuPointerSetAttribute)(value, attribute, ptr)
+    err = (<CUresult (*)(const void*, CUpointer_attribute, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuPointerSetAttribute)(value, attribute, ptr)
     return err
 {{endif}}
 
@@ -9549,7 +9549,7 @@ cdef CUresult _cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attr
     if __cuPointerGetAttributes == NULL:
         with gil:
             raise RuntimeError('Function "cuPointerGetAttributes" not found')
-    err = (<CUresult (*)(unsigned int, CUpointer_attribute*, void**, CUdeviceptr) nogil> __cuPointerGetAttributes)(numAttributes, attributes, data, ptr)
+    err = (<CUresult (*)(unsigned int, CUpointer_attribute*, void**, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuPointerGetAttributes)(numAttributes, attributes, data, ptr)
     return err
 {{endif}}
 
@@ -9561,7 +9561,7 @@ cdef CUresult _cuStreamCreate(CUstream* phStream, unsigned int Flags) except ?CU
     if __cuStreamCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamCreate" not found')
-    err = (<CUresult (*)(CUstream*, unsigned int) nogil> __cuStreamCreate)(phStream, Flags)
+    err = (<CUresult (*)(CUstream*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamCreate)(phStream, Flags)
     return err
 {{endif}}
 
@@ -9573,7 +9573,7 @@ cdef CUresult _cuStreamCreateWithPriority(CUstream* phStream, unsigned int flags
     if __cuStreamCreateWithPriority == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamCreateWithPriority" not found')
-    err = (<CUresult (*)(CUstream*, unsigned int, int) nogil> __cuStreamCreateWithPriority)(phStream, flags, priority)
+    err = (<CUresult (*)(CUstream*, unsigned int, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamCreateWithPriority)(phStream, flags, priority)
     return err
 {{endif}}
 
@@ -9585,7 +9585,7 @@ cdef CUresult _cuStreamGetPriority(CUstream hStream, int* priority) except ?CUDA
     if __cuStreamGetPriority == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetPriority" not found')
-    err = (<CUresult (*)(CUstream, int*) nogil> __cuStreamGetPriority)(hStream, priority)
+    err = (<CUresult (*)(CUstream, int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetPriority)(hStream, priority)
     return err
 {{endif}}
 
@@ -9597,7 +9597,7 @@ cdef CUresult _cuStreamGetFlags(CUstream hStream, unsigned int* flags) except ?C
     if __cuStreamGetFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetFlags" not found')
-    err = (<CUresult (*)(CUstream, unsigned int*) nogil> __cuStreamGetFlags)(hStream, flags)
+    err = (<CUresult (*)(CUstream, unsigned int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetFlags)(hStream, flags)
     return err
 {{endif}}
 
@@ -9609,7 +9609,7 @@ cdef CUresult _cuStreamGetCtx(CUstream hStream, CUcontext* pctx) except ?CUDA_ER
     if __cuStreamGetCtx == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetCtx" not found')
-    err = (<CUresult (*)(CUstream, CUcontext*) nogil> __cuStreamGetCtx)(hStream, pctx)
+    err = (<CUresult (*)(CUstream, CUcontext*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetCtx)(hStream, pctx)
     return err
 {{endif}}
 
@@ -9621,7 +9621,7 @@ cdef CUresult _cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int
     if __cuStreamWaitEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWaitEvent" not found')
-    err = (<CUresult (*)(CUstream, CUevent, unsigned int) nogil> __cuStreamWaitEvent)(hStream, hEvent, Flags)
+    err = (<CUresult (*)(CUstream, CUevent, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWaitEvent)(hStream, hEvent, Flags)
     return err
 {{endif}}
 
@@ -9633,7 +9633,7 @@ cdef CUresult _cuStreamAddCallback(CUstream hStream, CUstreamCallback callback,
     if __cuStreamAddCallback == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamAddCallback" not found')
-    err = (<CUresult (*)(CUstream, CUstreamCallback, void*, unsigned int) nogil> __cuStreamAddCallback)(hStream, callback, userData, flags)
+    err = (<CUresult (*)(CUstream, CUstreamCallback, void*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamAddCallback)(hStream, callback, userData, flags)
     return err
 {{endif}}
 
@@ -9645,7 +9645,7 @@ cdef CUresult _cuStreamBeginCapture_v2(CUstream hStream, CUstreamCaptureMode mod
     if __cuStreamBeginCapture_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamBeginCapture_v2" not found')
-    err = (<CUresult (*)(CUstream, CUstreamCaptureMode) nogil> __cuStreamBeginCapture_v2)(hStream, mode)
+    err = (<CUresult (*)(CUstream, CUstreamCaptureMode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamBeginCapture_v2)(hStream, mode)
     return err
 {{endif}}
 
@@ -9657,7 +9657,7 @@ cdef CUresult _cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode* mode) exce
     if __cuThreadExchangeStreamCaptureMode == NULL:
         with gil:
             raise RuntimeError('Function "cuThreadExchangeStreamCaptureMode" not found')
-    err = (<CUresult (*)(CUstreamCaptureMode*) nogil> __cuThreadExchangeStreamCaptureMode)(mode)
+    err = (<CUresult (*)(CUstreamCaptureMode*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuThreadExchangeStreamCaptureMode)(mode)
     return err
 {{endif}}
 
@@ -9669,7 +9669,7 @@ cdef CUresult _cuStreamEndCapture(CUstream hStream, CUgraph* phGraph) except ?CU
     if __cuStreamEndCapture == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamEndCapture" not found')
-    err = (<CUresult (*)(CUstream, CUgraph*) nogil> __cuStreamEndCapture)(hStream, phGraph)
+    err = (<CUresult (*)(CUstream, CUgraph*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamEndCapture)(hStream, phGraph)
     return err
 {{endif}}
 
@@ -9681,7 +9681,7 @@ cdef CUresult _cuStreamIsCapturing(CUstream hStream, CUstreamCaptureStatus* capt
     if __cuStreamIsCapturing == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamIsCapturing" not found')
-    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*) nogil> __cuStreamIsCapturing)(hStream, captureStatus)
+    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamIsCapturing)(hStream, captureStatus)
     return err
 {{endif}}
 
@@ -9693,7 +9693,7 @@ cdef CUresult _cuStreamGetCaptureInfo(CUstream hStream, CUstreamCaptureStatus* c
     if __cuStreamGetCaptureInfo == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetCaptureInfo" not found')
-    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*, cuuint64_t*) nogil> __cuStreamGetCaptureInfo)(hStream, captureStatus_out, id_out)
+    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*, cuuint64_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetCaptureInfo)(hStream, captureStatus_out, id_out)
     return err
 {{endif}}
 
@@ -9705,7 +9705,7 @@ cdef CUresult _cuStreamGetCaptureInfo_v2(CUstream hStream, CUstreamCaptureStatus
     if __cuStreamGetCaptureInfo_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetCaptureInfo_v2" not found')
-    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*, cuuint64_t*, CUgraph*, const CUgraphNode**, size_t*) nogil> __cuStreamGetCaptureInfo_v2)(hStream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
+    err = (<CUresult (*)(CUstream, CUstreamCaptureStatus*, cuuint64_t*, CUgraph*, const CUgraphNode**, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetCaptureInfo_v2)(hStream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
     return err
 {{endif}}
 
@@ -9717,7 +9717,7 @@ cdef CUresult _cuStreamUpdateCaptureDependencies(CUstream hStream, CUgraphNode*
     if __cuStreamUpdateCaptureDependencies == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamUpdateCaptureDependencies" not found')
-    err = (<CUresult (*)(CUstream, CUgraphNode*, size_t, unsigned int) nogil> __cuStreamUpdateCaptureDependencies)(hStream, dependencies, numDependencies, flags)
+    err = (<CUresult (*)(CUstream, CUgraphNode*, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamUpdateCaptureDependencies)(hStream, dependencies, numDependencies, flags)
     return err
 {{endif}}
 
@@ -9729,7 +9729,7 @@ cdef CUresult _cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t
     if __cuStreamAttachMemAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamAttachMemAsync" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, size_t, unsigned int) nogil> __cuStreamAttachMemAsync)(hStream, dptr, length, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamAttachMemAsync)(hStream, dptr, length, flags)
     return err
 {{endif}}
 
@@ -9741,7 +9741,7 @@ cdef CUresult _cuStreamQuery(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogi
     if __cuStreamQuery == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamQuery" not found')
-    err = (<CUresult (*)(CUstream) nogil> __cuStreamQuery)(hStream)
+    err = (<CUresult (*)(CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamQuery)(hStream)
     return err
 {{endif}}
 
@@ -9753,7 +9753,7 @@ cdef CUresult _cuStreamSynchronize(CUstream hStream) except ?CUDA_ERROR_NOT_FOUN
     if __cuStreamSynchronize == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamSynchronize" not found')
-    err = (<CUresult (*)(CUstream) nogil> __cuStreamSynchronize)(hStream)
+    err = (<CUresult (*)(CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamSynchronize)(hStream)
     return err
 {{endif}}
 
@@ -9765,7 +9765,7 @@ cdef CUresult _cuStreamDestroy_v2(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND
     if __cuStreamDestroy_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamDestroy_v2" not found')
-    err = (<CUresult (*)(CUstream) nogil> __cuStreamDestroy_v2)(hStream)
+    err = (<CUresult (*)(CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamDestroy_v2)(hStream)
     return err
 {{endif}}
 
@@ -9777,7 +9777,7 @@ cdef CUresult _cuStreamCopyAttributes(CUstream dst, CUstream src) except ?CUDA_E
     if __cuStreamCopyAttributes == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamCopyAttributes" not found')
-    err = (<CUresult (*)(CUstream, CUstream) nogil> __cuStreamCopyAttributes)(dst, src)
+    err = (<CUresult (*)(CUstream, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamCopyAttributes)(dst, src)
     return err
 {{endif}}
 
@@ -9789,7 +9789,7 @@ cdef CUresult _cuStreamGetAttribute(CUstream hStream, CUstreamAttrID attr, CUstr
     if __cuStreamGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamGetAttribute" not found')
-    err = (<CUresult (*)(CUstream, CUstreamAttrID, CUstreamAttrValue*) nogil> __cuStreamGetAttribute)(hStream, attr, value_out)
+    err = (<CUresult (*)(CUstream, CUstreamAttrID, CUstreamAttrValue*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamGetAttribute)(hStream, attr, value_out)
     return err
 {{endif}}
 
@@ -9801,7 +9801,7 @@ cdef CUresult _cuStreamSetAttribute(CUstream hStream, CUstreamAttrID attr, const
     if __cuStreamSetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamSetAttribute" not found')
-    err = (<CUresult (*)(CUstream, CUstreamAttrID, const CUstreamAttrValue*) nogil> __cuStreamSetAttribute)(hStream, attr, value)
+    err = (<CUresult (*)(CUstream, CUstreamAttrID, const CUstreamAttrValue*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamSetAttribute)(hStream, attr, value)
     return err
 {{endif}}
 
@@ -9813,7 +9813,7 @@ cdef CUresult _cuEventCreate(CUevent* phEvent, unsigned int Flags) except ?CUDA_
     if __cuEventCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuEventCreate" not found')
-    err = (<CUresult (*)(CUevent*, unsigned int) nogil> __cuEventCreate)(phEvent, Flags)
+    err = (<CUresult (*)(CUevent*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventCreate)(phEvent, Flags)
     return err
 {{endif}}
 
@@ -9825,7 +9825,7 @@ cdef CUresult _cuEventRecord(CUevent hEvent, CUstream hStream) except ?CUDA_ERRO
     if __cuEventRecord == NULL:
         with gil:
             raise RuntimeError('Function "cuEventRecord" not found')
-    err = (<CUresult (*)(CUevent, CUstream) nogil> __cuEventRecord)(hEvent, hStream)
+    err = (<CUresult (*)(CUevent, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventRecord)(hEvent, hStream)
     return err
 {{endif}}
 
@@ -9837,7 +9837,7 @@ cdef CUresult _cuEventRecordWithFlags(CUevent hEvent, CUstream hStream, unsigned
     if __cuEventRecordWithFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuEventRecordWithFlags" not found')
-    err = (<CUresult (*)(CUevent, CUstream, unsigned int) nogil> __cuEventRecordWithFlags)(hEvent, hStream, flags)
+    err = (<CUresult (*)(CUevent, CUstream, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventRecordWithFlags)(hEvent, hStream, flags)
     return err
 {{endif}}
 
@@ -9849,7 +9849,7 @@ cdef CUresult _cuEventQuery(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuEventQuery == NULL:
         with gil:
             raise RuntimeError('Function "cuEventQuery" not found')
-    err = (<CUresult (*)(CUevent) nogil> __cuEventQuery)(hEvent)
+    err = (<CUresult (*)(CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventQuery)(hEvent)
     return err
 {{endif}}
 
@@ -9861,7 +9861,7 @@ cdef CUresult _cuEventSynchronize(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND n
     if __cuEventSynchronize == NULL:
         with gil:
             raise RuntimeError('Function "cuEventSynchronize" not found')
-    err = (<CUresult (*)(CUevent) nogil> __cuEventSynchronize)(hEvent)
+    err = (<CUresult (*)(CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventSynchronize)(hEvent)
     return err
 {{endif}}
 
@@ -9873,7 +9873,7 @@ cdef CUresult _cuEventDestroy_v2(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND no
     if __cuEventDestroy_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuEventDestroy_v2" not found')
-    err = (<CUresult (*)(CUevent) nogil> __cuEventDestroy_v2)(hEvent)
+    err = (<CUresult (*)(CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventDestroy_v2)(hEvent)
     return err
 {{endif}}
 
@@ -9885,7 +9885,7 @@ cdef CUresult _cuEventElapsedTime(float* pMilliseconds, CUevent hStart, CUevent
     if __cuEventElapsedTime == NULL:
         with gil:
             raise RuntimeError('Function "cuEventElapsedTime" not found')
-    err = (<CUresult (*)(float*, CUevent, CUevent) nogil> __cuEventElapsedTime)(pMilliseconds, hStart, hEnd)
+    err = (<CUresult (*)(float*, CUevent, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventElapsedTime)(pMilliseconds, hStart, hEnd)
     return err
 {{endif}}
 
@@ -9897,7 +9897,7 @@ cdef CUresult _cuImportExternalMemory(CUexternalMemory* extMem_out, const CUDA_E
     if __cuImportExternalMemory == NULL:
         with gil:
             raise RuntimeError('Function "cuImportExternalMemory" not found')
-    err = (<CUresult (*)(CUexternalMemory*, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC*) nogil> __cuImportExternalMemory)(extMem_out, memHandleDesc)
+    err = (<CUresult (*)(CUexternalMemory*, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuImportExternalMemory)(extMem_out, memHandleDesc)
     return err
 {{endif}}
 
@@ -9909,7 +9909,7 @@ cdef CUresult _cuExternalMemoryGetMappedBuffer(CUdeviceptr* devPtr, CUexternalMe
     if __cuExternalMemoryGetMappedBuffer == NULL:
         with gil:
             raise RuntimeError('Function "cuExternalMemoryGetMappedBuffer" not found')
-    err = (<CUresult (*)(CUdeviceptr*, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC*) nogil> __cuExternalMemoryGetMappedBuffer)(devPtr, extMem, bufferDesc)
+    err = (<CUresult (*)(CUdeviceptr*, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuExternalMemoryGetMappedBuffer)(devPtr, extMem, bufferDesc)
     return err
 {{endif}}
 
@@ -9921,7 +9921,7 @@ cdef CUresult _cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray* mipmap,
     if __cuExternalMemoryGetMappedMipmappedArray == NULL:
         with gil:
             raise RuntimeError('Function "cuExternalMemoryGetMappedMipmappedArray" not found')
-    err = (<CUresult (*)(CUmipmappedArray*, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC*) nogil> __cuExternalMemoryGetMappedMipmappedArray)(mipmap, extMem, mipmapDesc)
+    err = (<CUresult (*)(CUmipmappedArray*, CUexternalMemory, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuExternalMemoryGetMappedMipmappedArray)(mipmap, extMem, mipmapDesc)
     return err
 {{endif}}
 
@@ -9933,7 +9933,7 @@ cdef CUresult _cuDestroyExternalMemory(CUexternalMemory extMem) except ?CUDA_ERR
     if __cuDestroyExternalMemory == NULL:
         with gil:
             raise RuntimeError('Function "cuDestroyExternalMemory" not found')
-    err = (<CUresult (*)(CUexternalMemory) nogil> __cuDestroyExternalMemory)(extMem)
+    err = (<CUresult (*)(CUexternalMemory) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDestroyExternalMemory)(extMem)
     return err
 {{endif}}
 
@@ -9945,7 +9945,7 @@ cdef CUresult _cuImportExternalSemaphore(CUexternalSemaphore* extSem_out, const
     if __cuImportExternalSemaphore == NULL:
         with gil:
             raise RuntimeError('Function "cuImportExternalSemaphore" not found')
-    err = (<CUresult (*)(CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC*) nogil> __cuImportExternalSemaphore)(extSem_out, semHandleDesc)
+    err = (<CUresult (*)(CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuImportExternalSemaphore)(extSem_out, semHandleDesc)
     return err
 {{endif}}
 
@@ -9957,7 +9957,7 @@ cdef CUresult _cuSignalExternalSemaphoresAsync(const CUexternalSemaphore* extSem
     if __cuSignalExternalSemaphoresAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuSignalExternalSemaphoresAsync" not found')
-    err = (<CUresult (*)(const CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*, unsigned int, CUstream) nogil> __cuSignalExternalSemaphoresAsync)(extSemArray, paramsArray, numExtSems, stream)
+    err = (<CUresult (*)(const CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*, unsigned int, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSignalExternalSemaphoresAsync)(extSemArray, paramsArray, numExtSems, stream)
     return err
 {{endif}}
 
@@ -9969,7 +9969,7 @@ cdef CUresult _cuWaitExternalSemaphoresAsync(const CUexternalSemaphore* extSemAr
     if __cuWaitExternalSemaphoresAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuWaitExternalSemaphoresAsync" not found')
-    err = (<CUresult (*)(const CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*, unsigned int, CUstream) nogil> __cuWaitExternalSemaphoresAsync)(extSemArray, paramsArray, numExtSems, stream)
+    err = (<CUresult (*)(const CUexternalSemaphore*, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*, unsigned int, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuWaitExternalSemaphoresAsync)(extSemArray, paramsArray, numExtSems, stream)
     return err
 {{endif}}
 
@@ -9981,7 +9981,7 @@ cdef CUresult _cuDestroyExternalSemaphore(CUexternalSemaphore extSem) except ?CU
     if __cuDestroyExternalSemaphore == NULL:
         with gil:
             raise RuntimeError('Function "cuDestroyExternalSemaphore" not found')
-    err = (<CUresult (*)(CUexternalSemaphore) nogil> __cuDestroyExternalSemaphore)(extSem)
+    err = (<CUresult (*)(CUexternalSemaphore) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDestroyExternalSemaphore)(extSem)
     return err
 {{endif}}
 
@@ -9993,7 +9993,7 @@ cdef CUresult _cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t
     if __cuStreamWaitValue32 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWaitValue32" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) nogil> __cuStreamWaitValue32)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWaitValue32)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10005,7 +10005,7 @@ cdef CUresult _cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, cuuint64_t
     if __cuStreamWaitValue64 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWaitValue64" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) nogil> __cuStreamWaitValue64)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWaitValue64)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10017,7 +10017,7 @@ cdef CUresult _cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_
     if __cuStreamWriteValue32 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWriteValue32" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) nogil> __cuStreamWriteValue32)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWriteValue32)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10029,7 +10029,7 @@ cdef CUresult _cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, cuuint64_
     if __cuStreamWriteValue64 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWriteValue64" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) nogil> __cuStreamWriteValue64)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWriteValue64)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10041,7 +10041,7 @@ cdef CUresult _cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamB
     if __cuStreamBatchMemOp == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamBatchMemOp" not found')
-    err = (<CUresult (*)(CUstream, unsigned int, CUstreamBatchMemOpParams*, unsigned int) nogil> __cuStreamBatchMemOp)(stream, count, paramArray, flags)
+    err = (<CUresult (*)(CUstream, unsigned int, CUstreamBatchMemOpParams*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamBatchMemOp)(stream, count, paramArray, flags)
     return err
 {{endif}}
 
@@ -10053,7 +10053,7 @@ cdef CUresult _cuStreamWaitValue32_v2(CUstream stream, CUdeviceptr addr, cuuint3
     if __cuStreamWaitValue32_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWaitValue32_v2" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) nogil> __cuStreamWaitValue32_v2)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWaitValue32_v2)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10065,7 +10065,7 @@ cdef CUresult _cuStreamWaitValue64_v2(CUstream stream, CUdeviceptr addr, cuuint6
     if __cuStreamWaitValue64_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWaitValue64_v2" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) nogil> __cuStreamWaitValue64_v2)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWaitValue64_v2)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10077,7 +10077,7 @@ cdef CUresult _cuStreamWriteValue32_v2(CUstream stream, CUdeviceptr addr, cuuint
     if __cuStreamWriteValue32_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWriteValue32_v2" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) nogil> __cuStreamWriteValue32_v2)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint32_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWriteValue32_v2)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10089,7 +10089,7 @@ cdef CUresult _cuStreamWriteValue64_v2(CUstream stream, CUdeviceptr addr, cuuint
     if __cuStreamWriteValue64_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamWriteValue64_v2" not found')
-    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) nogil> __cuStreamWriteValue64_v2)(stream, addr, value, flags)
+    err = (<CUresult (*)(CUstream, CUdeviceptr, cuuint64_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamWriteValue64_v2)(stream, addr, value, flags)
     return err
 {{endif}}
 
@@ -10101,7 +10101,7 @@ cdef CUresult _cuStreamBatchMemOp_v2(CUstream stream, unsigned int count, CUstre
     if __cuStreamBatchMemOp_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuStreamBatchMemOp_v2" not found')
-    err = (<CUresult (*)(CUstream, unsigned int, CUstreamBatchMemOpParams*, unsigned int) nogil> __cuStreamBatchMemOp_v2)(stream, count, paramArray, flags)
+    err = (<CUresult (*)(CUstream, unsigned int, CUstreamBatchMemOpParams*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuStreamBatchMemOp_v2)(stream, count, paramArray, flags)
     return err
 {{endif}}
 
@@ -10113,7 +10113,7 @@ cdef CUresult _cuFuncGetAttribute(int* pi, CUfunction_attribute attrib, CUfuncti
     if __cuFuncGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncGetAttribute" not found')
-    err = (<CUresult (*)(int*, CUfunction_attribute, CUfunction) nogil> __cuFuncGetAttribute)(pi, attrib, hfunc)
+    err = (<CUresult (*)(int*, CUfunction_attribute, CUfunction) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncGetAttribute)(pi, attrib, hfunc)
     return err
 {{endif}}
 
@@ -10125,7 +10125,7 @@ cdef CUresult _cuFuncSetAttribute(CUfunction hfunc, CUfunction_attribute attrib,
     if __cuFuncSetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncSetAttribute" not found')
-    err = (<CUresult (*)(CUfunction, CUfunction_attribute, int) nogil> __cuFuncSetAttribute)(hfunc, attrib, value)
+    err = (<CUresult (*)(CUfunction, CUfunction_attribute, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncSetAttribute)(hfunc, attrib, value)
     return err
 {{endif}}
 
@@ -10137,7 +10137,7 @@ cdef CUresult _cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) excep
     if __cuFuncSetCacheConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncSetCacheConfig" not found')
-    err = (<CUresult (*)(CUfunction, CUfunc_cache) nogil> __cuFuncSetCacheConfig)(hfunc, config)
+    err = (<CUresult (*)(CUfunction, CUfunc_cache) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncSetCacheConfig)(hfunc, config)
     return err
 {{endif}}
 
@@ -10149,7 +10149,7 @@ cdef CUresult _cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config)
     if __cuFuncSetSharedMemConfig == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncSetSharedMemConfig" not found')
-    err = (<CUresult (*)(CUfunction, CUsharedconfig) nogil> __cuFuncSetSharedMemConfig)(hfunc, config)
+    err = (<CUresult (*)(CUfunction, CUsharedconfig) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncSetSharedMemConfig)(hfunc, config)
     return err
 {{endif}}
 
@@ -10161,7 +10161,7 @@ cdef CUresult _cuFuncGetModule(CUmodule* hmod, CUfunction hfunc) except ?CUDA_ER
     if __cuFuncGetModule == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncGetModule" not found')
-    err = (<CUresult (*)(CUmodule*, CUfunction) nogil> __cuFuncGetModule)(hmod, hfunc)
+    err = (<CUresult (*)(CUmodule*, CUfunction) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncGetModule)(hmod, hfunc)
     return err
 {{endif}}
 
@@ -10173,7 +10173,7 @@ cdef CUresult _cuLaunchKernel(CUfunction f, unsigned int gridDimX, unsigned int
     if __cuLaunchKernel == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchKernel" not found')
-    err = (<CUresult (*)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void**, void**) nogil> __cuLaunchKernel)(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra)
+    err = (<CUresult (*)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void**, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchKernel)(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra)
     return err
 {{endif}}
 
@@ -10185,7 +10185,7 @@ cdef CUresult _cuLaunchKernelEx(const CUlaunchConfig* config, CUfunction f, void
     if __cuLaunchKernelEx == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchKernelEx" not found')
-    err = (<CUresult (*)(const CUlaunchConfig*, CUfunction, void**, void**) nogil> __cuLaunchKernelEx)(config, f, kernelParams, extra)
+    err = (<CUresult (*)(const CUlaunchConfig*, CUfunction, void**, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchKernelEx)(config, f, kernelParams, extra)
     return err
 {{endif}}
 
@@ -10197,7 +10197,7 @@ cdef CUresult _cuLaunchCooperativeKernel(CUfunction f, unsigned int gridDimX, un
     if __cuLaunchCooperativeKernel == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchCooperativeKernel" not found')
-    err = (<CUresult (*)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void**) nogil> __cuLaunchCooperativeKernel)(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams)
+    err = (<CUresult (*)(CUfunction, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int, CUstream, void**) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchCooperativeKernel)(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams)
     return err
 {{endif}}
 
@@ -10209,7 +10209,7 @@ cdef CUresult _cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS* launchPa
     if __cuLaunchCooperativeKernelMultiDevice == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchCooperativeKernelMultiDevice" not found')
-    err = (<CUresult (*)(CUDA_LAUNCH_PARAMS*, unsigned int, unsigned int) nogil> __cuLaunchCooperativeKernelMultiDevice)(launchParamsList, numDevices, flags)
+    err = (<CUresult (*)(CUDA_LAUNCH_PARAMS*, unsigned int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchCooperativeKernelMultiDevice)(launchParamsList, numDevices, flags)
     return err
 {{endif}}
 
@@ -10221,7 +10221,7 @@ cdef CUresult _cuLaunchHostFunc(CUstream hStream, CUhostFn fn, void* userData) e
     if __cuLaunchHostFunc == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchHostFunc" not found')
-    err = (<CUresult (*)(CUstream, CUhostFn, void*) nogil> __cuLaunchHostFunc)(hStream, fn, userData)
+    err = (<CUresult (*)(CUstream, CUhostFn, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchHostFunc)(hStream, fn, userData)
     return err
 {{endif}}
 
@@ -10233,7 +10233,7 @@ cdef CUresult _cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z) except
     if __cuFuncSetBlockShape == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncSetBlockShape" not found')
-    err = (<CUresult (*)(CUfunction, int, int, int) nogil> __cuFuncSetBlockShape)(hfunc, x, y, z)
+    err = (<CUresult (*)(CUfunction, int, int, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncSetBlockShape)(hfunc, x, y, z)
     return err
 {{endif}}
 
@@ -10245,7 +10245,7 @@ cdef CUresult _cuFuncSetSharedSize(CUfunction hfunc, unsigned int numbytes) exce
     if __cuFuncSetSharedSize == NULL:
         with gil:
             raise RuntimeError('Function "cuFuncSetSharedSize" not found')
-    err = (<CUresult (*)(CUfunction, unsigned int) nogil> __cuFuncSetSharedSize)(hfunc, numbytes)
+    err = (<CUresult (*)(CUfunction, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuFuncSetSharedSize)(hfunc, numbytes)
     return err
 {{endif}}
 
@@ -10257,7 +10257,7 @@ cdef CUresult _cuParamSetSize(CUfunction hfunc, unsigned int numbytes) except ?C
     if __cuParamSetSize == NULL:
         with gil:
             raise RuntimeError('Function "cuParamSetSize" not found')
-    err = (<CUresult (*)(CUfunction, unsigned int) nogil> __cuParamSetSize)(hfunc, numbytes)
+    err = (<CUresult (*)(CUfunction, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuParamSetSize)(hfunc, numbytes)
     return err
 {{endif}}
 
@@ -10269,7 +10269,7 @@ cdef CUresult _cuParamSeti(CUfunction hfunc, int offset, unsigned int value) exc
     if __cuParamSeti == NULL:
         with gil:
             raise RuntimeError('Function "cuParamSeti" not found')
-    err = (<CUresult (*)(CUfunction, int, unsigned int) nogil> __cuParamSeti)(hfunc, offset, value)
+    err = (<CUresult (*)(CUfunction, int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuParamSeti)(hfunc, offset, value)
     return err
 {{endif}}
 
@@ -10281,7 +10281,7 @@ cdef CUresult _cuParamSetf(CUfunction hfunc, int offset, float value) except ?CU
     if __cuParamSetf == NULL:
         with gil:
             raise RuntimeError('Function "cuParamSetf" not found')
-    err = (<CUresult (*)(CUfunction, int, float) nogil> __cuParamSetf)(hfunc, offset, value)
+    err = (<CUresult (*)(CUfunction, int, float) except ?CUDA_ERROR_NOT_FOUND nogil> __cuParamSetf)(hfunc, offset, value)
     return err
 {{endif}}
 
@@ -10293,7 +10293,7 @@ cdef CUresult _cuParamSetv(CUfunction hfunc, int offset, void* ptr, unsigned int
     if __cuParamSetv == NULL:
         with gil:
             raise RuntimeError('Function "cuParamSetv" not found')
-    err = (<CUresult (*)(CUfunction, int, void*, unsigned int) nogil> __cuParamSetv)(hfunc, offset, ptr, numbytes)
+    err = (<CUresult (*)(CUfunction, int, void*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuParamSetv)(hfunc, offset, ptr, numbytes)
     return err
 {{endif}}
 
@@ -10305,7 +10305,7 @@ cdef CUresult _cuLaunch(CUfunction f) except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuLaunch == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunch" not found')
-    err = (<CUresult (*)(CUfunction) nogil> __cuLaunch)(f)
+    err = (<CUresult (*)(CUfunction) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunch)(f)
     return err
 {{endif}}
 
@@ -10317,7 +10317,7 @@ cdef CUresult _cuLaunchGrid(CUfunction f, int grid_width, int grid_height) excep
     if __cuLaunchGrid == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchGrid" not found')
-    err = (<CUresult (*)(CUfunction, int, int) nogil> __cuLaunchGrid)(f, grid_width, grid_height)
+    err = (<CUresult (*)(CUfunction, int, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchGrid)(f, grid_width, grid_height)
     return err
 {{endif}}
 
@@ -10329,7 +10329,7 @@ cdef CUresult _cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height,
     if __cuLaunchGridAsync == NULL:
         with gil:
             raise RuntimeError('Function "cuLaunchGridAsync" not found')
-    err = (<CUresult (*)(CUfunction, int, int, CUstream) nogil> __cuLaunchGridAsync)(f, grid_width, grid_height, hStream)
+    err = (<CUresult (*)(CUfunction, int, int, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuLaunchGridAsync)(f, grid_width, grid_height, hStream)
     return err
 {{endif}}
 
@@ -10341,7 +10341,7 @@ cdef CUresult _cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef)
     if __cuParamSetTexRef == NULL:
         with gil:
             raise RuntimeError('Function "cuParamSetTexRef" not found')
-    err = (<CUresult (*)(CUfunction, int, CUtexref) nogil> __cuParamSetTexRef)(hfunc, texunit, hTexRef)
+    err = (<CUresult (*)(CUfunction, int, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuParamSetTexRef)(hfunc, texunit, hTexRef)
     return err
 {{endif}}
 
@@ -10353,7 +10353,7 @@ cdef CUresult _cuGraphCreate(CUgraph* phGraph, unsigned int flags) except ?CUDA_
     if __cuGraphCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphCreate" not found')
-    err = (<CUresult (*)(CUgraph*, unsigned int) nogil> __cuGraphCreate)(phGraph, flags)
+    err = (<CUresult (*)(CUgraph*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphCreate)(phGraph, flags)
     return err
 {{endif}}
 
@@ -10365,7 +10365,7 @@ cdef CUresult _cuGraphAddKernelNode(CUgraphNode* phGraphNode, CUgraph hGraph, co
     if __cuGraphAddKernelNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddKernelNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_KERNEL_NODE_PARAMS*) nogil> __cuGraphAddKernelNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_KERNEL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddKernelNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10377,7 +10377,7 @@ cdef CUresult _cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PA
     if __cuGraphKernelNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphKernelNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS*) nogil> __cuGraphKernelNodeGetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, CUDA_KERNEL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphKernelNodeGetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10389,7 +10389,7 @@ cdef CUresult _cuGraphKernelNodeSetParams(CUgraphNode hNode, const CUDA_KERNEL_N
     if __cuGraphKernelNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphKernelNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS*) nogil> __cuGraphKernelNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_KERNEL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphKernelNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10401,7 +10401,7 @@ cdef CUresult _cuGraphAddMemcpyNode(CUgraphNode* phGraphNode, CUgraph hGraph, co
     if __cuGraphAddMemcpyNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddMemcpyNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_MEMCPY3D*, CUcontext) nogil> __cuGraphAddMemcpyNode)(phGraphNode, hGraph, dependencies, numDependencies, copyParams, ctx)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_MEMCPY3D*, CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddMemcpyNode)(phGraphNode, hGraph, dependencies, numDependencies, copyParams, ctx)
     return err
 {{endif}}
 
@@ -10413,7 +10413,7 @@ cdef CUresult _cuGraphMemcpyNodeGetParams(CUgraphNode hNode, CUDA_MEMCPY3D* node
     if __cuGraphMemcpyNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemcpyNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_MEMCPY3D*) nogil> __cuGraphMemcpyNodeGetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, CUDA_MEMCPY3D*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemcpyNodeGetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10425,7 +10425,7 @@ cdef CUresult _cuGraphMemcpyNodeSetParams(CUgraphNode hNode, const CUDA_MEMCPY3D
     if __cuGraphMemcpyNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemcpyNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_MEMCPY3D*) nogil> __cuGraphMemcpyNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_MEMCPY3D*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemcpyNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10437,7 +10437,7 @@ cdef CUresult _cuGraphAddMemsetNode(CUgraphNode* phGraphNode, CUgraph hGraph, co
     if __cuGraphAddMemsetNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddMemsetNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_MEMSET_NODE_PARAMS*, CUcontext) nogil> __cuGraphAddMemsetNode)(phGraphNode, hGraph, dependencies, numDependencies, memsetParams, ctx)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_MEMSET_NODE_PARAMS*, CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddMemsetNode)(phGraphNode, hGraph, dependencies, numDependencies, memsetParams, ctx)
     return err
 {{endif}}
 
@@ -10449,7 +10449,7 @@ cdef CUresult _cuGraphMemsetNodeGetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PA
     if __cuGraphMemsetNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemsetNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS*) nogil> __cuGraphMemsetNodeGetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, CUDA_MEMSET_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemsetNodeGetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10461,7 +10461,7 @@ cdef CUresult _cuGraphMemsetNodeSetParams(CUgraphNode hNode, const CUDA_MEMSET_N
     if __cuGraphMemsetNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemsetNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS*) nogil> __cuGraphMemsetNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_MEMSET_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemsetNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10473,7 +10473,7 @@ cdef CUresult _cuGraphAddHostNode(CUgraphNode* phGraphNode, CUgraph hGraph, cons
     if __cuGraphAddHostNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddHostNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_HOST_NODE_PARAMS*) nogil> __cuGraphAddHostNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_HOST_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddHostNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10485,7 +10485,7 @@ cdef CUresult _cuGraphHostNodeGetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS
     if __cuGraphHostNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphHostNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_HOST_NODE_PARAMS*) nogil> __cuGraphHostNodeGetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, CUDA_HOST_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphHostNodeGetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10497,7 +10497,7 @@ cdef CUresult _cuGraphHostNodeSetParams(CUgraphNode hNode, const CUDA_HOST_NODE_
     if __cuGraphHostNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphHostNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_HOST_NODE_PARAMS*) nogil> __cuGraphHostNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_HOST_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphHostNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10509,7 +10509,7 @@ cdef CUresult _cuGraphAddChildGraphNode(CUgraphNode* phGraphNode, CUgraph hGraph
     if __cuGraphAddChildGraphNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddChildGraphNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUgraph) nogil> __cuGraphAddChildGraphNode)(phGraphNode, hGraph, dependencies, numDependencies, childGraph)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUgraph) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddChildGraphNode)(phGraphNode, hGraph, dependencies, numDependencies, childGraph)
     return err
 {{endif}}
 
@@ -10521,7 +10521,7 @@ cdef CUresult _cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, CUgraph* phGraph
     if __cuGraphChildGraphNodeGetGraph == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphChildGraphNodeGetGraph" not found')
-    err = (<CUresult (*)(CUgraphNode, CUgraph*) nogil> __cuGraphChildGraphNodeGetGraph)(hNode, phGraph)
+    err = (<CUresult (*)(CUgraphNode, CUgraph*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphChildGraphNodeGetGraph)(hNode, phGraph)
     return err
 {{endif}}
 
@@ -10533,7 +10533,7 @@ cdef CUresult _cuGraphAddEmptyNode(CUgraphNode* phGraphNode, CUgraph hGraph, con
     if __cuGraphAddEmptyNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddEmptyNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t) nogil> __cuGraphAddEmptyNode)(phGraphNode, hGraph, dependencies, numDependencies)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddEmptyNode)(phGraphNode, hGraph, dependencies, numDependencies)
     return err
 {{endif}}
 
@@ -10545,7 +10545,7 @@ cdef CUresult _cuGraphAddEventRecordNode(CUgraphNode* phGraphNode, CUgraph hGrap
     if __cuGraphAddEventRecordNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddEventRecordNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUevent) nogil> __cuGraphAddEventRecordNode)(phGraphNode, hGraph, dependencies, numDependencies, event)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddEventRecordNode)(phGraphNode, hGraph, dependencies, numDependencies, event)
     return err
 {{endif}}
 
@@ -10557,7 +10557,7 @@ cdef CUresult _cuGraphEventRecordNodeGetEvent(CUgraphNode hNode, CUevent* event_
     if __cuGraphEventRecordNodeGetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphEventRecordNodeGetEvent" not found')
-    err = (<CUresult (*)(CUgraphNode, CUevent*) nogil> __cuGraphEventRecordNodeGetEvent)(hNode, event_out)
+    err = (<CUresult (*)(CUgraphNode, CUevent*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphEventRecordNodeGetEvent)(hNode, event_out)
     return err
 {{endif}}
 
@@ -10569,7 +10569,7 @@ cdef CUresult _cuGraphEventRecordNodeSetEvent(CUgraphNode hNode, CUevent event)
     if __cuGraphEventRecordNodeSetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphEventRecordNodeSetEvent" not found')
-    err = (<CUresult (*)(CUgraphNode, CUevent) nogil> __cuGraphEventRecordNodeSetEvent)(hNode, event)
+    err = (<CUresult (*)(CUgraphNode, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphEventRecordNodeSetEvent)(hNode, event)
     return err
 {{endif}}
 
@@ -10581,7 +10581,7 @@ cdef CUresult _cuGraphAddEventWaitNode(CUgraphNode* phGraphNode, CUgraph hGraph,
     if __cuGraphAddEventWaitNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddEventWaitNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUevent) nogil> __cuGraphAddEventWaitNode)(phGraphNode, hGraph, dependencies, numDependencies, event)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddEventWaitNode)(phGraphNode, hGraph, dependencies, numDependencies, event)
     return err
 {{endif}}
 
@@ -10593,7 +10593,7 @@ cdef CUresult _cuGraphEventWaitNodeGetEvent(CUgraphNode hNode, CUevent* event_ou
     if __cuGraphEventWaitNodeGetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphEventWaitNodeGetEvent" not found')
-    err = (<CUresult (*)(CUgraphNode, CUevent*) nogil> __cuGraphEventWaitNodeGetEvent)(hNode, event_out)
+    err = (<CUresult (*)(CUgraphNode, CUevent*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphEventWaitNodeGetEvent)(hNode, event_out)
     return err
 {{endif}}
 
@@ -10605,7 +10605,7 @@ cdef CUresult _cuGraphEventWaitNodeSetEvent(CUgraphNode hNode, CUevent event) ex
     if __cuGraphEventWaitNodeSetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphEventWaitNodeSetEvent" not found')
-    err = (<CUresult (*)(CUgraphNode, CUevent) nogil> __cuGraphEventWaitNodeSetEvent)(hNode, event)
+    err = (<CUresult (*)(CUgraphNode, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphEventWaitNodeSetEvent)(hNode, event)
     return err
 {{endif}}
 
@@ -10617,7 +10617,7 @@ cdef CUresult _cuGraphAddExternalSemaphoresSignalNode(CUgraphNode* phGraphNode,
     if __cuGraphAddExternalSemaphoresSignalNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddExternalSemaphoresSignalNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) nogil> __cuGraphAddExternalSemaphoresSignalNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddExternalSemaphoresSignalNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10629,7 +10629,7 @@ cdef CUresult _cuGraphExternalSemaphoresSignalNodeGetParams(CUgraphNode hNode, C
     if __cuGraphExternalSemaphoresSignalNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExternalSemaphoresSignalNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) nogil> __cuGraphExternalSemaphoresSignalNodeGetParams)(hNode, params_out)
+    err = (<CUresult (*)(CUgraphNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExternalSemaphoresSignalNodeGetParams)(hNode, params_out)
     return err
 {{endif}}
 
@@ -10641,7 +10641,7 @@ cdef CUresult _cuGraphExternalSemaphoresSignalNodeSetParams(CUgraphNode hNode, c
     if __cuGraphExternalSemaphoresSignalNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExternalSemaphoresSignalNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) nogil> __cuGraphExternalSemaphoresSignalNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExternalSemaphoresSignalNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10653,7 +10653,7 @@ cdef CUresult _cuGraphAddExternalSemaphoresWaitNode(CUgraphNode* phGraphNode, CU
     if __cuGraphAddExternalSemaphoresWaitNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddExternalSemaphoresWaitNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) nogil> __cuGraphAddExternalSemaphoresWaitNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddExternalSemaphoresWaitNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10665,7 +10665,7 @@ cdef CUresult _cuGraphExternalSemaphoresWaitNodeGetParams(CUgraphNode hNode, CUD
     if __cuGraphExternalSemaphoresWaitNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExternalSemaphoresWaitNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS*) nogil> __cuGraphExternalSemaphoresWaitNodeGetParams)(hNode, params_out)
+    err = (<CUresult (*)(CUgraphNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExternalSemaphoresWaitNodeGetParams)(hNode, params_out)
     return err
 {{endif}}
 
@@ -10677,7 +10677,7 @@ cdef CUresult _cuGraphExternalSemaphoresWaitNodeSetParams(CUgraphNode hNode, con
     if __cuGraphExternalSemaphoresWaitNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExternalSemaphoresWaitNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) nogil> __cuGraphExternalSemaphoresWaitNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExternalSemaphoresWaitNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10689,7 +10689,7 @@ cdef CUresult _cuGraphAddBatchMemOpNode(CUgraphNode* phGraphNode, CUgraph hGraph
     if __cuGraphAddBatchMemOpNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddBatchMemOpNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) nogil> __cuGraphAddBatchMemOpNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddBatchMemOpNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10701,7 +10701,7 @@ cdef CUresult _cuGraphBatchMemOpNodeGetParams(CUgraphNode hNode, CUDA_BATCH_MEM_
     if __cuGraphBatchMemOpNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphBatchMemOpNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_BATCH_MEM_OP_NODE_PARAMS*) nogil> __cuGraphBatchMemOpNodeGetParams)(hNode, nodeParams_out)
+    err = (<CUresult (*)(CUgraphNode, CUDA_BATCH_MEM_OP_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphBatchMemOpNodeGetParams)(hNode, nodeParams_out)
     return err
 {{endif}}
 
@@ -10713,7 +10713,7 @@ cdef CUresult _cuGraphBatchMemOpNodeSetParams(CUgraphNode hNode, const CUDA_BATC
     if __cuGraphBatchMemOpNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphBatchMemOpNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) nogil> __cuGraphBatchMemOpNodeSetParams)(hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphBatchMemOpNodeSetParams)(hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10725,7 +10725,7 @@ cdef CUresult _cuGraphExecBatchMemOpNodeSetParams(CUgraphExec hGraphExec, CUgrap
     if __cuGraphExecBatchMemOpNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecBatchMemOpNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) nogil> __cuGraphExecBatchMemOpNodeSetParams)(hGraphExec, hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecBatchMemOpNodeSetParams)(hGraphExec, hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10737,7 +10737,7 @@ cdef CUresult _cuGraphAddMemAllocNode(CUgraphNode* phGraphNode, CUgraph hGraph,
     if __cuGraphAddMemAllocNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddMemAllocNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUDA_MEM_ALLOC_NODE_PARAMS*) nogil> __cuGraphAddMemAllocNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUDA_MEM_ALLOC_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddMemAllocNode)(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
     return err
 {{endif}}
 
@@ -10749,7 +10749,7 @@ cdef CUresult _cuGraphMemAllocNodeGetParams(CUgraphNode hNode, CUDA_MEM_ALLOC_NO
     if __cuGraphMemAllocNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemAllocNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUDA_MEM_ALLOC_NODE_PARAMS*) nogil> __cuGraphMemAllocNodeGetParams)(hNode, params_out)
+    err = (<CUresult (*)(CUgraphNode, CUDA_MEM_ALLOC_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemAllocNodeGetParams)(hNode, params_out)
     return err
 {{endif}}
 
@@ -10761,7 +10761,7 @@ cdef CUresult _cuGraphAddMemFreeNode(CUgraphNode* phGraphNode, CUgraph hGraph, c
     if __cuGraphAddMemFreeNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddMemFreeNode" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUdeviceptr) nogil> __cuGraphAddMemFreeNode)(phGraphNode, hGraph, dependencies, numDependencies, dptr)
+    err = (<CUresult (*)(CUgraphNode*, CUgraph, const CUgraphNode*, size_t, CUdeviceptr) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddMemFreeNode)(phGraphNode, hGraph, dependencies, numDependencies, dptr)
     return err
 {{endif}}
 
@@ -10773,7 +10773,7 @@ cdef CUresult _cuGraphMemFreeNodeGetParams(CUgraphNode hNode, CUdeviceptr* dptr_
     if __cuGraphMemFreeNodeGetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphMemFreeNodeGetParams" not found')
-    err = (<CUresult (*)(CUgraphNode, CUdeviceptr*) nogil> __cuGraphMemFreeNodeGetParams)(hNode, dptr_out)
+    err = (<CUresult (*)(CUgraphNode, CUdeviceptr*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphMemFreeNodeGetParams)(hNode, dptr_out)
     return err
 {{endif}}
 
@@ -10785,7 +10785,7 @@ cdef CUresult _cuDeviceGraphMemTrim(CUdevice device) except ?CUDA_ERROR_NOT_FOUN
     if __cuDeviceGraphMemTrim == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGraphMemTrim" not found')
-    err = (<CUresult (*)(CUdevice) nogil> __cuDeviceGraphMemTrim)(device)
+    err = (<CUresult (*)(CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGraphMemTrim)(device)
     return err
 {{endif}}
 
@@ -10797,7 +10797,7 @@ cdef CUresult _cuDeviceGetGraphMemAttribute(CUdevice device, CUgraphMem_attribut
     if __cuDeviceGetGraphMemAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetGraphMemAttribute" not found')
-    err = (<CUresult (*)(CUdevice, CUgraphMem_attribute, void*) nogil> __cuDeviceGetGraphMemAttribute)(device, attr, value)
+    err = (<CUresult (*)(CUdevice, CUgraphMem_attribute, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetGraphMemAttribute)(device, attr, value)
     return err
 {{endif}}
 
@@ -10809,7 +10809,7 @@ cdef CUresult _cuDeviceSetGraphMemAttribute(CUdevice device, CUgraphMem_attribut
     if __cuDeviceSetGraphMemAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceSetGraphMemAttribute" not found')
-    err = (<CUresult (*)(CUdevice, CUgraphMem_attribute, void*) nogil> __cuDeviceSetGraphMemAttribute)(device, attr, value)
+    err = (<CUresult (*)(CUdevice, CUgraphMem_attribute, void*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceSetGraphMemAttribute)(device, attr, value)
     return err
 {{endif}}
 
@@ -10821,7 +10821,7 @@ cdef CUresult _cuGraphClone(CUgraph* phGraphClone, CUgraph originalGraph) except
     if __cuGraphClone == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphClone" not found')
-    err = (<CUresult (*)(CUgraph*, CUgraph) nogil> __cuGraphClone)(phGraphClone, originalGraph)
+    err = (<CUresult (*)(CUgraph*, CUgraph) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphClone)(phGraphClone, originalGraph)
     return err
 {{endif}}
 
@@ -10833,7 +10833,7 @@ cdef CUresult _cuGraphNodeFindInClone(CUgraphNode* phNode, CUgraphNode hOriginal
     if __cuGraphNodeFindInClone == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeFindInClone" not found')
-    err = (<CUresult (*)(CUgraphNode*, CUgraphNode, CUgraph) nogil> __cuGraphNodeFindInClone)(phNode, hOriginalNode, hClonedGraph)
+    err = (<CUresult (*)(CUgraphNode*, CUgraphNode, CUgraph) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeFindInClone)(phNode, hOriginalNode, hClonedGraph)
     return err
 {{endif}}
 
@@ -10845,7 +10845,7 @@ cdef CUresult _cuGraphNodeGetType(CUgraphNode hNode, CUgraphNodeType* typename)
     if __cuGraphNodeGetType == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeGetType" not found')
-    err = (<CUresult (*)(CUgraphNode, CUgraphNodeType*) nogil> __cuGraphNodeGetType)(hNode, typename)
+    err = (<CUresult (*)(CUgraphNode, CUgraphNodeType*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeGetType)(hNode, typename)
     return err
 {{endif}}
 
@@ -10857,7 +10857,7 @@ cdef CUresult _cuGraphGetNodes(CUgraph hGraph, CUgraphNode* nodes, size_t* numNo
     if __cuGraphGetNodes == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphGetNodes" not found')
-    err = (<CUresult (*)(CUgraph, CUgraphNode*, size_t*) nogil> __cuGraphGetNodes)(hGraph, nodes, numNodes)
+    err = (<CUresult (*)(CUgraph, CUgraphNode*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphGetNodes)(hGraph, nodes, numNodes)
     return err
 {{endif}}
 
@@ -10869,7 +10869,7 @@ cdef CUresult _cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode* rootNodes, size_
     if __cuGraphGetRootNodes == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphGetRootNodes" not found')
-    err = (<CUresult (*)(CUgraph, CUgraphNode*, size_t*) nogil> __cuGraphGetRootNodes)(hGraph, rootNodes, numRootNodes)
+    err = (<CUresult (*)(CUgraph, CUgraphNode*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphGetRootNodes)(hGraph, rootNodes, numRootNodes)
     return err
 {{endif}}
 
@@ -10881,7 +10881,7 @@ cdef CUresult _cuGraphGetEdges(CUgraph hGraph, CUgraphNode* from_, CUgraphNode*
     if __cuGraphGetEdges == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphGetEdges" not found')
-    err = (<CUresult (*)(CUgraph, CUgraphNode*, CUgraphNode*, size_t*) nogil> __cuGraphGetEdges)(hGraph, from_, to, numEdges)
+    err = (<CUresult (*)(CUgraph, CUgraphNode*, CUgraphNode*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphGetEdges)(hGraph, from_, to, numEdges)
     return err
 {{endif}}
 
@@ -10893,7 +10893,7 @@ cdef CUresult _cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode* depend
     if __cuGraphNodeGetDependencies == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeGetDependencies" not found')
-    err = (<CUresult (*)(CUgraphNode, CUgraphNode*, size_t*) nogil> __cuGraphNodeGetDependencies)(hNode, dependencies, numDependencies)
+    err = (<CUresult (*)(CUgraphNode, CUgraphNode*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeGetDependencies)(hNode, dependencies, numDependencies)
     return err
 {{endif}}
 
@@ -10905,7 +10905,7 @@ cdef CUresult _cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode* depe
     if __cuGraphNodeGetDependentNodes == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeGetDependentNodes" not found')
-    err = (<CUresult (*)(CUgraphNode, CUgraphNode*, size_t*) nogil> __cuGraphNodeGetDependentNodes)(hNode, dependentNodes, numDependentNodes)
+    err = (<CUresult (*)(CUgraphNode, CUgraphNode*, size_t*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeGetDependentNodes)(hNode, dependentNodes, numDependentNodes)
     return err
 {{endif}}
 
@@ -10917,7 +10917,7 @@ cdef CUresult _cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode* from_,
     if __cuGraphAddDependencies == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphAddDependencies" not found')
-    err = (<CUresult (*)(CUgraph, const CUgraphNode*, const CUgraphNode*, size_t) nogil> __cuGraphAddDependencies)(hGraph, from_, to, numDependencies)
+    err = (<CUresult (*)(CUgraph, const CUgraphNode*, const CUgraphNode*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphAddDependencies)(hGraph, from_, to, numDependencies)
     return err
 {{endif}}
 
@@ -10929,7 +10929,7 @@ cdef CUresult _cuGraphRemoveDependencies(CUgraph hGraph, const CUgraphNode* from
     if __cuGraphRemoveDependencies == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphRemoveDependencies" not found')
-    err = (<CUresult (*)(CUgraph, const CUgraphNode*, const CUgraphNode*, size_t) nogil> __cuGraphRemoveDependencies)(hGraph, from_, to, numDependencies)
+    err = (<CUresult (*)(CUgraph, const CUgraphNode*, const CUgraphNode*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphRemoveDependencies)(hGraph, from_, to, numDependencies)
     return err
 {{endif}}
 
@@ -10941,7 +10941,7 @@ cdef CUresult _cuGraphDestroyNode(CUgraphNode hNode) except ?CUDA_ERROR_NOT_FOUN
     if __cuGraphDestroyNode == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphDestroyNode" not found')
-    err = (<CUresult (*)(CUgraphNode) nogil> __cuGraphDestroyNode)(hNode)
+    err = (<CUresult (*)(CUgraphNode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphDestroyNode)(hNode)
     return err
 {{endif}}
 
@@ -10953,7 +10953,7 @@ cdef CUresult _cuGraphInstantiate_v2(CUgraphExec* phGraphExec, CUgraph hGraph, C
     if __cuGraphInstantiate_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphInstantiate_v2" not found')
-    err = (<CUresult (*)(CUgraphExec*, CUgraph, CUgraphNode*, char*, size_t) nogil> __cuGraphInstantiate_v2)(phGraphExec, hGraph, phErrorNode, logBuffer, bufferSize)
+    err = (<CUresult (*)(CUgraphExec*, CUgraph, CUgraphNode*, char*, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphInstantiate_v2)(phGraphExec, hGraph, phErrorNode, logBuffer, bufferSize)
     return err
 {{endif}}
 
@@ -10965,7 +10965,7 @@ cdef CUresult _cuGraphInstantiateWithFlags(CUgraphExec* phGraphExec, CUgraph hGr
     if __cuGraphInstantiateWithFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphInstantiateWithFlags" not found')
-    err = (<CUresult (*)(CUgraphExec*, CUgraph, unsigned long long) nogil> __cuGraphInstantiateWithFlags)(phGraphExec, hGraph, flags)
+    err = (<CUresult (*)(CUgraphExec*, CUgraph, unsigned long long) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphInstantiateWithFlags)(phGraphExec, hGraph, flags)
     return err
 {{endif}}
 
@@ -10977,7 +10977,7 @@ cdef CUresult _cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNod
     if __cuGraphExecKernelNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecKernelNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS*) nogil> __cuGraphExecKernelNodeSetParams)(hGraphExec, hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_KERNEL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecKernelNodeSetParams)(hGraphExec, hNode, nodeParams)
     return err
 {{endif}}
 
@@ -10989,7 +10989,7 @@ cdef CUresult _cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec, CUgraphNod
     if __cuGraphExecMemcpyNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecMemcpyNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D*, CUcontext) nogil> __cuGraphExecMemcpyNodeSetParams)(hGraphExec, hNode, copyParams, ctx)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_MEMCPY3D*, CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecMemcpyNodeSetParams)(hGraphExec, hNode, copyParams, ctx)
     return err
 {{endif}}
 
@@ -11001,7 +11001,7 @@ cdef CUresult _cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec, CUgraphNod
     if __cuGraphExecMemsetNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecMemsetNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS*, CUcontext) nogil> __cuGraphExecMemsetNodeSetParams)(hGraphExec, hNode, memsetParams, ctx)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_MEMSET_NODE_PARAMS*, CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecMemsetNodeSetParams)(hGraphExec, hNode, memsetParams, ctx)
     return err
 {{endif}}
 
@@ -11013,7 +11013,7 @@ cdef CUresult _cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec, CUgraphNode
     if __cuGraphExecHostNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecHostNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS*) nogil> __cuGraphExecHostNodeSetParams)(hGraphExec, hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_HOST_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecHostNodeSetParams)(hGraphExec, hNode, nodeParams)
     return err
 {{endif}}
 
@@ -11025,7 +11025,7 @@ cdef CUresult _cuGraphExecChildGraphNodeSetParams(CUgraphExec hGraphExec, CUgrap
     if __cuGraphExecChildGraphNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecChildGraphNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUgraph) nogil> __cuGraphExecChildGraphNodeSetParams)(hGraphExec, hNode, childGraph)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUgraph) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecChildGraphNodeSetParams)(hGraphExec, hNode, childGraph)
     return err
 {{endif}}
 
@@ -11037,7 +11037,7 @@ cdef CUresult _cuGraphExecEventRecordNodeSetEvent(CUgraphExec hGraphExec, CUgrap
     if __cuGraphExecEventRecordNodeSetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecEventRecordNodeSetEvent" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUevent) nogil> __cuGraphExecEventRecordNodeSetEvent)(hGraphExec, hNode, event)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecEventRecordNodeSetEvent)(hGraphExec, hNode, event)
     return err
 {{endif}}
 
@@ -11049,7 +11049,7 @@ cdef CUresult _cuGraphExecEventWaitNodeSetEvent(CUgraphExec hGraphExec, CUgraphN
     if __cuGraphExecEventWaitNodeSetEvent == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecEventWaitNodeSetEvent" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUevent) nogil> __cuGraphExecEventWaitNodeSetEvent)(hGraphExec, hNode, event)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, CUevent) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecEventWaitNodeSetEvent)(hGraphExec, hNode, event)
     return err
 {{endif}}
 
@@ -11061,7 +11061,7 @@ cdef CUresult _cuGraphExecExternalSemaphoresSignalNodeSetParams(CUgraphExec hGra
     if __cuGraphExecExternalSemaphoresSignalNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecExternalSemaphoresSignalNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) nogil> __cuGraphExecExternalSemaphoresSignalNodeSetParams)(hGraphExec, hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecExternalSemaphoresSignalNodeSetParams)(hGraphExec, hNode, nodeParams)
     return err
 {{endif}}
 
@@ -11073,7 +11073,7 @@ cdef CUresult _cuGraphExecExternalSemaphoresWaitNodeSetParams(CUgraphExec hGraph
     if __cuGraphExecExternalSemaphoresWaitNodeSetParams == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecExternalSemaphoresWaitNodeSetParams" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) nogil> __cuGraphExecExternalSemaphoresWaitNodeSetParams)(hGraphExec, hNode, nodeParams)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecExternalSemaphoresWaitNodeSetParams)(hGraphExec, hNode, nodeParams)
     return err
 {{endif}}
 
@@ -11085,7 +11085,7 @@ cdef CUresult _cuGraphNodeSetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode,
     if __cuGraphNodeSetEnabled == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeSetEnabled" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, unsigned int) nogil> __cuGraphNodeSetEnabled)(hGraphExec, hNode, isEnabled)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeSetEnabled)(hGraphExec, hNode, isEnabled)
     return err
 {{endif}}
 
@@ -11097,7 +11097,7 @@ cdef CUresult _cuGraphNodeGetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode,
     if __cuGraphNodeGetEnabled == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphNodeGetEnabled" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraphNode, unsigned int*) nogil> __cuGraphNodeGetEnabled)(hGraphExec, hNode, isEnabled)
+    err = (<CUresult (*)(CUgraphExec, CUgraphNode, unsigned int*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphNodeGetEnabled)(hGraphExec, hNode, isEnabled)
     return err
 {{endif}}
 
@@ -11109,7 +11109,7 @@ cdef CUresult _cuGraphUpload(CUgraphExec hGraphExec, CUstream hStream) except ?C
     if __cuGraphUpload == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphUpload" not found')
-    err = (<CUresult (*)(CUgraphExec, CUstream) nogil> __cuGraphUpload)(hGraphExec, hStream)
+    err = (<CUresult (*)(CUgraphExec, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphUpload)(hGraphExec, hStream)
     return err
 {{endif}}
 
@@ -11121,7 +11121,7 @@ cdef CUresult _cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream) except ?C
     if __cuGraphLaunch == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphLaunch" not found')
-    err = (<CUresult (*)(CUgraphExec, CUstream) nogil> __cuGraphLaunch)(hGraphExec, hStream)
+    err = (<CUresult (*)(CUgraphExec, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphLaunch)(hGraphExec, hStream)
     return err
 {{endif}}
 
@@ -11133,7 +11133,7 @@ cdef CUresult _cuGraphExecDestroy(CUgraphExec hGraphExec) except ?CUDA_ERROR_NOT
     if __cuGraphExecDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecDestroy" not found')
-    err = (<CUresult (*)(CUgraphExec) nogil> __cuGraphExecDestroy)(hGraphExec)
+    err = (<CUresult (*)(CUgraphExec) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecDestroy)(hGraphExec)
     return err
 {{endif}}
 
@@ -11145,7 +11145,7 @@ cdef CUresult _cuGraphDestroy(CUgraph hGraph) except ?CUDA_ERROR_NOT_FOUND nogil
     if __cuGraphDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphDestroy" not found')
-    err = (<CUresult (*)(CUgraph) nogil> __cuGraphDestroy)(hGraph)
+    err = (<CUresult (*)(CUgraph) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphDestroy)(hGraph)
     return err
 {{endif}}
 
@@ -11157,7 +11157,7 @@ cdef CUresult _cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraph
     if __cuGraphExecUpdate == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphExecUpdate" not found')
-    err = (<CUresult (*)(CUgraphExec, CUgraph, CUgraphNode*, CUgraphExecUpdateResult*) nogil> __cuGraphExecUpdate)(hGraphExec, hGraph, hErrorNode_out, updateResult_out)
+    err = (<CUresult (*)(CUgraphExec, CUgraph, CUgraphNode*, CUgraphExecUpdateResult*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphExecUpdate)(hGraphExec, hGraph, hErrorNode_out, updateResult_out)
     return err
 {{endif}}
 
@@ -11169,7 +11169,7 @@ cdef CUresult _cuGraphKernelNodeCopyAttributes(CUgraphNode dst, CUgraphNode src)
     if __cuGraphKernelNodeCopyAttributes == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphKernelNodeCopyAttributes" not found')
-    err = (<CUresult (*)(CUgraphNode, CUgraphNode) nogil> __cuGraphKernelNodeCopyAttributes)(dst, src)
+    err = (<CUresult (*)(CUgraphNode, CUgraphNode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphKernelNodeCopyAttributes)(dst, src)
     return err
 {{endif}}
 
@@ -11181,7 +11181,7 @@ cdef CUresult _cuGraphKernelNodeGetAttribute(CUgraphNode hNode, CUkernelNodeAttr
     if __cuGraphKernelNodeGetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphKernelNodeGetAttribute" not found')
-    err = (<CUresult (*)(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue*) nogil> __cuGraphKernelNodeGetAttribute)(hNode, attr, value_out)
+    err = (<CUresult (*)(CUgraphNode, CUkernelNodeAttrID, CUkernelNodeAttrValue*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphKernelNodeGetAttribute)(hNode, attr, value_out)
     return err
 {{endif}}
 
@@ -11193,7 +11193,7 @@ cdef CUresult _cuGraphKernelNodeSetAttribute(CUgraphNode hNode, CUkernelNodeAttr
     if __cuGraphKernelNodeSetAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphKernelNodeSetAttribute" not found')
-    err = (<CUresult (*)(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue*) nogil> __cuGraphKernelNodeSetAttribute)(hNode, attr, value)
+    err = (<CUresult (*)(CUgraphNode, CUkernelNodeAttrID, const CUkernelNodeAttrValue*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphKernelNodeSetAttribute)(hNode, attr, value)
     return err
 {{endif}}
 
@@ -11205,7 +11205,7 @@ cdef CUresult _cuGraphDebugDotPrint(CUgraph hGraph, const char* path, unsigned i
     if __cuGraphDebugDotPrint == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphDebugDotPrint" not found')
-    err = (<CUresult (*)(CUgraph, const char*, unsigned int) nogil> __cuGraphDebugDotPrint)(hGraph, path, flags)
+    err = (<CUresult (*)(CUgraph, const char*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphDebugDotPrint)(hGraph, path, flags)
     return err
 {{endif}}
 
@@ -11217,7 +11217,7 @@ cdef CUresult _cuUserObjectCreate(CUuserObject* object_out, void* ptr, CUhostFn
     if __cuUserObjectCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuUserObjectCreate" not found')
-    err = (<CUresult (*)(CUuserObject*, void*, CUhostFn, unsigned int, unsigned int) nogil> __cuUserObjectCreate)(object_out, ptr, destroy, initialRefcount, flags)
+    err = (<CUresult (*)(CUuserObject*, void*, CUhostFn, unsigned int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuUserObjectCreate)(object_out, ptr, destroy, initialRefcount, flags)
     return err
 {{endif}}
 
@@ -11229,7 +11229,7 @@ cdef CUresult _cuUserObjectRetain(CUuserObject object, unsigned int count) excep
     if __cuUserObjectRetain == NULL:
         with gil:
             raise RuntimeError('Function "cuUserObjectRetain" not found')
-    err = (<CUresult (*)(CUuserObject, unsigned int) nogil> __cuUserObjectRetain)(object, count)
+    err = (<CUresult (*)(CUuserObject, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuUserObjectRetain)(object, count)
     return err
 {{endif}}
 
@@ -11241,7 +11241,7 @@ cdef CUresult _cuUserObjectRelease(CUuserObject object, unsigned int count) exce
     if __cuUserObjectRelease == NULL:
         with gil:
             raise RuntimeError('Function "cuUserObjectRelease" not found')
-    err = (<CUresult (*)(CUuserObject, unsigned int) nogil> __cuUserObjectRelease)(object, count)
+    err = (<CUresult (*)(CUuserObject, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuUserObjectRelease)(object, count)
     return err
 {{endif}}
 
@@ -11253,7 +11253,7 @@ cdef CUresult _cuGraphRetainUserObject(CUgraph graph, CUuserObject object, unsig
     if __cuGraphRetainUserObject == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphRetainUserObject" not found')
-    err = (<CUresult (*)(CUgraph, CUuserObject, unsigned int, unsigned int) nogil> __cuGraphRetainUserObject)(graph, object, count, flags)
+    err = (<CUresult (*)(CUgraph, CUuserObject, unsigned int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphRetainUserObject)(graph, object, count, flags)
     return err
 {{endif}}
 
@@ -11265,7 +11265,7 @@ cdef CUresult _cuGraphReleaseUserObject(CUgraph graph, CUuserObject object, unsi
     if __cuGraphReleaseUserObject == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphReleaseUserObject" not found')
-    err = (<CUresult (*)(CUgraph, CUuserObject, unsigned int) nogil> __cuGraphReleaseUserObject)(graph, object, count)
+    err = (<CUresult (*)(CUgraph, CUuserObject, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphReleaseUserObject)(graph, object, count)
     return err
 {{endif}}
 
@@ -11277,7 +11277,7 @@ cdef CUresult _cuOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, CUfun
     if __cuOccupancyMaxActiveBlocksPerMultiprocessor == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxActiveBlocksPerMultiprocessor" not found')
-    err = (<CUresult (*)(int*, CUfunction, int, size_t) nogil> __cuOccupancyMaxActiveBlocksPerMultiprocessor)(numBlocks, func, blockSize, dynamicSMemSize)
+    err = (<CUresult (*)(int*, CUfunction, int, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxActiveBlocksPerMultiprocessor)(numBlocks, func, blockSize, dynamicSMemSize)
     return err
 {{endif}}
 
@@ -11289,7 +11289,7 @@ cdef CUresult _cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBloc
     if __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags" not found')
-    err = (<CUresult (*)(int*, CUfunction, int, size_t, unsigned int) nogil> __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)(numBlocks, func, blockSize, dynamicSMemSize, flags)
+    err = (<CUresult (*)(int*, CUfunction, int, size_t, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags)(numBlocks, func, blockSize, dynamicSMemSize, flags)
     return err
 {{endif}}
 
@@ -11301,7 +11301,7 @@ cdef CUresult _cuOccupancyMaxPotentialBlockSize(int* minGridSize, int* blockSize
     if __cuOccupancyMaxPotentialBlockSize == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxPotentialBlockSize" not found')
-    err = (<CUresult (*)(int*, int*, CUfunction, CUoccupancyB2DSize, size_t, int) nogil> __cuOccupancyMaxPotentialBlockSize)(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
+    err = (<CUresult (*)(int*, int*, CUfunction, CUoccupancyB2DSize, size_t, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxPotentialBlockSize)(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
     return err
 {{endif}}
 
@@ -11313,7 +11313,7 @@ cdef CUresult _cuOccupancyMaxPotentialBlockSizeWithFlags(int* minGridSize, int*
     if __cuOccupancyMaxPotentialBlockSizeWithFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxPotentialBlockSizeWithFlags" not found')
-    err = (<CUresult (*)(int*, int*, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) nogil> __cuOccupancyMaxPotentialBlockSizeWithFlags)(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
+    err = (<CUresult (*)(int*, int*, CUfunction, CUoccupancyB2DSize, size_t, int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxPotentialBlockSizeWithFlags)(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
     return err
 {{endif}}
 
@@ -11325,7 +11325,7 @@ cdef CUresult _cuOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize,
     if __cuOccupancyAvailableDynamicSMemPerBlock == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyAvailableDynamicSMemPerBlock" not found')
-    err = (<CUresult (*)(size_t*, CUfunction, int, int) nogil> __cuOccupancyAvailableDynamicSMemPerBlock)(dynamicSmemSize, func, numBlocks, blockSize)
+    err = (<CUresult (*)(size_t*, CUfunction, int, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyAvailableDynamicSMemPerBlock)(dynamicSmemSize, func, numBlocks, blockSize)
     return err
 {{endif}}
 
@@ -11337,7 +11337,7 @@ cdef CUresult _cuOccupancyMaxPotentialClusterSize(int* clusterSize, CUfunction f
     if __cuOccupancyMaxPotentialClusterSize == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxPotentialClusterSize" not found')
-    err = (<CUresult (*)(int*, CUfunction, const CUlaunchConfig*) nogil> __cuOccupancyMaxPotentialClusterSize)(clusterSize, func, config)
+    err = (<CUresult (*)(int*, CUfunction, const CUlaunchConfig*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxPotentialClusterSize)(clusterSize, func, config)
     return err
 {{endif}}
 
@@ -11349,7 +11349,7 @@ cdef CUresult _cuOccupancyMaxActiveClusters(int* numClusters, CUfunction func, c
     if __cuOccupancyMaxActiveClusters == NULL:
         with gil:
             raise RuntimeError('Function "cuOccupancyMaxActiveClusters" not found')
-    err = (<CUresult (*)(int*, CUfunction, const CUlaunchConfig*) nogil> __cuOccupancyMaxActiveClusters)(numClusters, func, config)
+    err = (<CUresult (*)(int*, CUfunction, const CUlaunchConfig*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuOccupancyMaxActiveClusters)(numClusters, func, config)
     return err
 {{endif}}
 
@@ -11361,7 +11361,7 @@ cdef CUresult _cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int F
     if __cuTexRefSetArray == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetArray" not found')
-    err = (<CUresult (*)(CUtexref, CUarray, unsigned int) nogil> __cuTexRefSetArray)(hTexRef, hArray, Flags)
+    err = (<CUresult (*)(CUtexref, CUarray, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetArray)(hTexRef, hArray, Flags)
     return err
 {{endif}}
 
@@ -11373,7 +11373,7 @@ cdef CUresult _cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMip
     if __cuTexRefSetMipmappedArray == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetMipmappedArray" not found')
-    err = (<CUresult (*)(CUtexref, CUmipmappedArray, unsigned int) nogil> __cuTexRefSetMipmappedArray)(hTexRef, hMipmappedArray, Flags)
+    err = (<CUresult (*)(CUtexref, CUmipmappedArray, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetMipmappedArray)(hTexRef, hMipmappedArray, Flags)
     return err
 {{endif}}
 
@@ -11385,7 +11385,7 @@ cdef CUresult _cuTexRefSetAddress_v2(size_t* ByteOffset, CUtexref hTexRef, CUdev
     if __cuTexRefSetAddress_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetAddress_v2" not found')
-    err = (<CUresult (*)(size_t*, CUtexref, CUdeviceptr, size_t) nogil> __cuTexRefSetAddress_v2)(ByteOffset, hTexRef, dptr, numbytes)
+    err = (<CUresult (*)(size_t*, CUtexref, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetAddress_v2)(ByteOffset, hTexRef, dptr, numbytes)
     return err
 {{endif}}
 
@@ -11397,7 +11397,7 @@ cdef CUresult _cuTexRefSetAddress2D_v3(CUtexref hTexRef, const CUDA_ARRAY_DESCRI
     if __cuTexRefSetAddress2D_v3 == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetAddress2D_v3" not found')
-    err = (<CUresult (*)(CUtexref, const CUDA_ARRAY_DESCRIPTOR*, CUdeviceptr, size_t) nogil> __cuTexRefSetAddress2D_v3)(hTexRef, desc, dptr, Pitch)
+    err = (<CUresult (*)(CUtexref, const CUDA_ARRAY_DESCRIPTOR*, CUdeviceptr, size_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetAddress2D_v3)(hTexRef, desc, dptr, Pitch)
     return err
 {{endif}}
 
@@ -11409,7 +11409,7 @@ cdef CUresult _cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPa
     if __cuTexRefSetFormat == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetFormat" not found')
-    err = (<CUresult (*)(CUtexref, CUarray_format, int) nogil> __cuTexRefSetFormat)(hTexRef, fmt, NumPackedComponents)
+    err = (<CUresult (*)(CUtexref, CUarray_format, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetFormat)(hTexRef, fmt, NumPackedComponents)
     return err
 {{endif}}
 
@@ -11421,7 +11421,7 @@ cdef CUresult _cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode
     if __cuTexRefSetAddressMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetAddressMode" not found')
-    err = (<CUresult (*)(CUtexref, int, CUaddress_mode) nogil> __cuTexRefSetAddressMode)(hTexRef, dim, am)
+    err = (<CUresult (*)(CUtexref, int, CUaddress_mode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetAddressMode)(hTexRef, dim, am)
     return err
 {{endif}}
 
@@ -11433,7 +11433,7 @@ cdef CUresult _cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) except
     if __cuTexRefSetFilterMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetFilterMode" not found')
-    err = (<CUresult (*)(CUtexref, CUfilter_mode) nogil> __cuTexRefSetFilterMode)(hTexRef, fm)
+    err = (<CUresult (*)(CUtexref, CUfilter_mode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetFilterMode)(hTexRef, fm)
     return err
 {{endif}}
 
@@ -11445,7 +11445,7 @@ cdef CUresult _cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm) e
     if __cuTexRefSetMipmapFilterMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetMipmapFilterMode" not found')
-    err = (<CUresult (*)(CUtexref, CUfilter_mode) nogil> __cuTexRefSetMipmapFilterMode)(hTexRef, fm)
+    err = (<CUresult (*)(CUtexref, CUfilter_mode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetMipmapFilterMode)(hTexRef, fm)
     return err
 {{endif}}
 
@@ -11457,7 +11457,7 @@ cdef CUresult _cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) except ?
     if __cuTexRefSetMipmapLevelBias == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetMipmapLevelBias" not found')
-    err = (<CUresult (*)(CUtexref, float) nogil> __cuTexRefSetMipmapLevelBias)(hTexRef, bias)
+    err = (<CUresult (*)(CUtexref, float) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetMipmapLevelBias)(hTexRef, bias)
     return err
 {{endif}}
 
@@ -11469,7 +11469,7 @@ cdef CUresult _cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLeve
     if __cuTexRefSetMipmapLevelClamp == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetMipmapLevelClamp" not found')
-    err = (<CUresult (*)(CUtexref, float, float) nogil> __cuTexRefSetMipmapLevelClamp)(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
+    err = (<CUresult (*)(CUtexref, float, float) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetMipmapLevelClamp)(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
     return err
 {{endif}}
 
@@ -11481,7 +11481,7 @@ cdef CUresult _cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso)
     if __cuTexRefSetMaxAnisotropy == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetMaxAnisotropy" not found')
-    err = (<CUresult (*)(CUtexref, unsigned int) nogil> __cuTexRefSetMaxAnisotropy)(hTexRef, maxAniso)
+    err = (<CUresult (*)(CUtexref, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetMaxAnisotropy)(hTexRef, maxAniso)
     return err
 {{endif}}
 
@@ -11493,7 +11493,7 @@ cdef CUresult _cuTexRefSetBorderColor(CUtexref hTexRef, float* pBorderColor) exc
     if __cuTexRefSetBorderColor == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetBorderColor" not found')
-    err = (<CUresult (*)(CUtexref, float*) nogil> __cuTexRefSetBorderColor)(hTexRef, pBorderColor)
+    err = (<CUresult (*)(CUtexref, float*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetBorderColor)(hTexRef, pBorderColor)
     return err
 {{endif}}
 
@@ -11505,7 +11505,7 @@ cdef CUresult _cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) except ?CU
     if __cuTexRefSetFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefSetFlags" not found')
-    err = (<CUresult (*)(CUtexref, unsigned int) nogil> __cuTexRefSetFlags)(hTexRef, Flags)
+    err = (<CUresult (*)(CUtexref, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefSetFlags)(hTexRef, Flags)
     return err
 {{endif}}
 
@@ -11517,7 +11517,7 @@ cdef CUresult _cuTexRefGetAddress_v2(CUdeviceptr* pdptr, CUtexref hTexRef) excep
     if __cuTexRefGetAddress_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetAddress_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, CUtexref) nogil> __cuTexRefGetAddress_v2)(pdptr, hTexRef)
+    err = (<CUresult (*)(CUdeviceptr*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetAddress_v2)(pdptr, hTexRef)
     return err
 {{endif}}
 
@@ -11529,7 +11529,7 @@ cdef CUresult _cuTexRefGetArray(CUarray* phArray, CUtexref hTexRef) except ?CUDA
     if __cuTexRefGetArray == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetArray" not found')
-    err = (<CUresult (*)(CUarray*, CUtexref) nogil> __cuTexRefGetArray)(phArray, hTexRef)
+    err = (<CUresult (*)(CUarray*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetArray)(phArray, hTexRef)
     return err
 {{endif}}
 
@@ -11541,7 +11541,7 @@ cdef CUresult _cuTexRefGetMipmappedArray(CUmipmappedArray* phMipmappedArray, CUt
     if __cuTexRefGetMipmappedArray == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetMipmappedArray" not found')
-    err = (<CUresult (*)(CUmipmappedArray*, CUtexref) nogil> __cuTexRefGetMipmappedArray)(phMipmappedArray, hTexRef)
+    err = (<CUresult (*)(CUmipmappedArray*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetMipmappedArray)(phMipmappedArray, hTexRef)
     return err
 {{endif}}
 
@@ -11553,7 +11553,7 @@ cdef CUresult _cuTexRefGetAddressMode(CUaddress_mode* pam, CUtexref hTexRef, int
     if __cuTexRefGetAddressMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetAddressMode" not found')
-    err = (<CUresult (*)(CUaddress_mode*, CUtexref, int) nogil> __cuTexRefGetAddressMode)(pam, hTexRef, dim)
+    err = (<CUresult (*)(CUaddress_mode*, CUtexref, int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetAddressMode)(pam, hTexRef, dim)
     return err
 {{endif}}
 
@@ -11565,7 +11565,7 @@ cdef CUresult _cuTexRefGetFilterMode(CUfilter_mode* pfm, CUtexref hTexRef) excep
     if __cuTexRefGetFilterMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetFilterMode" not found')
-    err = (<CUresult (*)(CUfilter_mode*, CUtexref) nogil> __cuTexRefGetFilterMode)(pfm, hTexRef)
+    err = (<CUresult (*)(CUfilter_mode*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetFilterMode)(pfm, hTexRef)
     return err
 {{endif}}
 
@@ -11577,7 +11577,7 @@ cdef CUresult _cuTexRefGetFormat(CUarray_format* pFormat, int* pNumChannels, CUt
     if __cuTexRefGetFormat == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetFormat" not found')
-    err = (<CUresult (*)(CUarray_format*, int*, CUtexref) nogil> __cuTexRefGetFormat)(pFormat, pNumChannels, hTexRef)
+    err = (<CUresult (*)(CUarray_format*, int*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetFormat)(pFormat, pNumChannels, hTexRef)
     return err
 {{endif}}
 
@@ -11589,7 +11589,7 @@ cdef CUresult _cuTexRefGetMipmapFilterMode(CUfilter_mode* pfm, CUtexref hTexRef)
     if __cuTexRefGetMipmapFilterMode == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetMipmapFilterMode" not found')
-    err = (<CUresult (*)(CUfilter_mode*, CUtexref) nogil> __cuTexRefGetMipmapFilterMode)(pfm, hTexRef)
+    err = (<CUresult (*)(CUfilter_mode*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetMipmapFilterMode)(pfm, hTexRef)
     return err
 {{endif}}
 
@@ -11601,7 +11601,7 @@ cdef CUresult _cuTexRefGetMipmapLevelBias(float* pbias, CUtexref hTexRef) except
     if __cuTexRefGetMipmapLevelBias == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetMipmapLevelBias" not found')
-    err = (<CUresult (*)(float*, CUtexref) nogil> __cuTexRefGetMipmapLevelBias)(pbias, hTexRef)
+    err = (<CUresult (*)(float*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetMipmapLevelBias)(pbias, hTexRef)
     return err
 {{endif}}
 
@@ -11613,7 +11613,7 @@ cdef CUresult _cuTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* p
     if __cuTexRefGetMipmapLevelClamp == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetMipmapLevelClamp" not found')
-    err = (<CUresult (*)(float*, float*, CUtexref) nogil> __cuTexRefGetMipmapLevelClamp)(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef)
+    err = (<CUresult (*)(float*, float*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetMipmapLevelClamp)(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef)
     return err
 {{endif}}
 
@@ -11625,7 +11625,7 @@ cdef CUresult _cuTexRefGetMaxAnisotropy(int* pmaxAniso, CUtexref hTexRef) except
     if __cuTexRefGetMaxAnisotropy == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetMaxAnisotropy" not found')
-    err = (<CUresult (*)(int*, CUtexref) nogil> __cuTexRefGetMaxAnisotropy)(pmaxAniso, hTexRef)
+    err = (<CUresult (*)(int*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetMaxAnisotropy)(pmaxAniso, hTexRef)
     return err
 {{endif}}
 
@@ -11637,7 +11637,7 @@ cdef CUresult _cuTexRefGetBorderColor(float* pBorderColor, CUtexref hTexRef) exc
     if __cuTexRefGetBorderColor == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetBorderColor" not found')
-    err = (<CUresult (*)(float*, CUtexref) nogil> __cuTexRefGetBorderColor)(pBorderColor, hTexRef)
+    err = (<CUresult (*)(float*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetBorderColor)(pBorderColor, hTexRef)
     return err
 {{endif}}
 
@@ -11649,7 +11649,7 @@ cdef CUresult _cuTexRefGetFlags(unsigned int* pFlags, CUtexref hTexRef) except ?
     if __cuTexRefGetFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefGetFlags" not found')
-    err = (<CUresult (*)(unsigned int*, CUtexref) nogil> __cuTexRefGetFlags)(pFlags, hTexRef)
+    err = (<CUresult (*)(unsigned int*, CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefGetFlags)(pFlags, hTexRef)
     return err
 {{endif}}
 
@@ -11661,7 +11661,7 @@ cdef CUresult _cuTexRefCreate(CUtexref* pTexRef) except ?CUDA_ERROR_NOT_FOUND no
     if __cuTexRefCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefCreate" not found')
-    err = (<CUresult (*)(CUtexref*) nogil> __cuTexRefCreate)(pTexRef)
+    err = (<CUresult (*)(CUtexref*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefCreate)(pTexRef)
     return err
 {{endif}}
 
@@ -11673,7 +11673,7 @@ cdef CUresult _cuTexRefDestroy(CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND no
     if __cuTexRefDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuTexRefDestroy" not found')
-    err = (<CUresult (*)(CUtexref) nogil> __cuTexRefDestroy)(hTexRef)
+    err = (<CUresult (*)(CUtexref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexRefDestroy)(hTexRef)
     return err
 {{endif}}
 
@@ -11685,7 +11685,7 @@ cdef CUresult _cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned in
     if __cuSurfRefSetArray == NULL:
         with gil:
             raise RuntimeError('Function "cuSurfRefSetArray" not found')
-    err = (<CUresult (*)(CUsurfref, CUarray, unsigned int) nogil> __cuSurfRefSetArray)(hSurfRef, hArray, Flags)
+    err = (<CUresult (*)(CUsurfref, CUarray, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSurfRefSetArray)(hSurfRef, hArray, Flags)
     return err
 {{endif}}
 
@@ -11697,7 +11697,7 @@ cdef CUresult _cuSurfRefGetArray(CUarray* phArray, CUsurfref hSurfRef) except ?C
     if __cuSurfRefGetArray == NULL:
         with gil:
             raise RuntimeError('Function "cuSurfRefGetArray" not found')
-    err = (<CUresult (*)(CUarray*, CUsurfref) nogil> __cuSurfRefGetArray)(phArray, hSurfRef)
+    err = (<CUresult (*)(CUarray*, CUsurfref) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSurfRefGetArray)(phArray, hSurfRef)
     return err
 {{endif}}
 
@@ -11709,7 +11709,7 @@ cdef CUresult _cuTexObjectCreate(CUtexObject* pTexObject, const CUDA_RESOURCE_DE
     if __cuTexObjectCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuTexObjectCreate" not found')
-    err = (<CUresult (*)(CUtexObject*, const CUDA_RESOURCE_DESC*, const CUDA_TEXTURE_DESC*, const CUDA_RESOURCE_VIEW_DESC*) nogil> __cuTexObjectCreate)(pTexObject, pResDesc, pTexDesc, pResViewDesc)
+    err = (<CUresult (*)(CUtexObject*, const CUDA_RESOURCE_DESC*, const CUDA_TEXTURE_DESC*, const CUDA_RESOURCE_VIEW_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexObjectCreate)(pTexObject, pResDesc, pTexDesc, pResViewDesc)
     return err
 {{endif}}
 
@@ -11721,7 +11721,7 @@ cdef CUresult _cuTexObjectDestroy(CUtexObject texObject) except ?CUDA_ERROR_NOT_
     if __cuTexObjectDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuTexObjectDestroy" not found')
-    err = (<CUresult (*)(CUtexObject) nogil> __cuTexObjectDestroy)(texObject)
+    err = (<CUresult (*)(CUtexObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexObjectDestroy)(texObject)
     return err
 {{endif}}
 
@@ -11733,7 +11733,7 @@ cdef CUresult _cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUtexObj
     if __cuTexObjectGetResourceDesc == NULL:
         with gil:
             raise RuntimeError('Function "cuTexObjectGetResourceDesc" not found')
-    err = (<CUresult (*)(CUDA_RESOURCE_DESC*, CUtexObject) nogil> __cuTexObjectGetResourceDesc)(pResDesc, texObject)
+    err = (<CUresult (*)(CUDA_RESOURCE_DESC*, CUtexObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexObjectGetResourceDesc)(pResDesc, texObject)
     return err
 {{endif}}
 
@@ -11745,7 +11745,7 @@ cdef CUresult _cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC* pTexDesc, CUtexObjec
     if __cuTexObjectGetTextureDesc == NULL:
         with gil:
             raise RuntimeError('Function "cuTexObjectGetTextureDesc" not found')
-    err = (<CUresult (*)(CUDA_TEXTURE_DESC*, CUtexObject) nogil> __cuTexObjectGetTextureDesc)(pTexDesc, texObject)
+    err = (<CUresult (*)(CUDA_TEXTURE_DESC*, CUtexObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexObjectGetTextureDesc)(pTexDesc, texObject)
     return err
 {{endif}}
 
@@ -11757,7 +11757,7 @@ cdef CUresult _cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC* pResViewD
     if __cuTexObjectGetResourceViewDesc == NULL:
         with gil:
             raise RuntimeError('Function "cuTexObjectGetResourceViewDesc" not found')
-    err = (<CUresult (*)(CUDA_RESOURCE_VIEW_DESC*, CUtexObject) nogil> __cuTexObjectGetResourceViewDesc)(pResViewDesc, texObject)
+    err = (<CUresult (*)(CUDA_RESOURCE_VIEW_DESC*, CUtexObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuTexObjectGetResourceViewDesc)(pResViewDesc, texObject)
     return err
 {{endif}}
 
@@ -11769,7 +11769,7 @@ cdef CUresult _cuSurfObjectCreate(CUsurfObject* pSurfObject, const CUDA_RESOURCE
     if __cuSurfObjectCreate == NULL:
         with gil:
             raise RuntimeError('Function "cuSurfObjectCreate" not found')
-    err = (<CUresult (*)(CUsurfObject*, const CUDA_RESOURCE_DESC*) nogil> __cuSurfObjectCreate)(pSurfObject, pResDesc)
+    err = (<CUresult (*)(CUsurfObject*, const CUDA_RESOURCE_DESC*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSurfObjectCreate)(pSurfObject, pResDesc)
     return err
 {{endif}}
 
@@ -11781,7 +11781,7 @@ cdef CUresult _cuSurfObjectDestroy(CUsurfObject surfObject) except ?CUDA_ERROR_N
     if __cuSurfObjectDestroy == NULL:
         with gil:
             raise RuntimeError('Function "cuSurfObjectDestroy" not found')
-    err = (<CUresult (*)(CUsurfObject) nogil> __cuSurfObjectDestroy)(surfObject)
+    err = (<CUresult (*)(CUsurfObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSurfObjectDestroy)(surfObject)
     return err
 {{endif}}
 
@@ -11793,7 +11793,7 @@ cdef CUresult _cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUsurfO
     if __cuSurfObjectGetResourceDesc == NULL:
         with gil:
             raise RuntimeError('Function "cuSurfObjectGetResourceDesc" not found')
-    err = (<CUresult (*)(CUDA_RESOURCE_DESC*, CUsurfObject) nogil> __cuSurfObjectGetResourceDesc)(pResDesc, surfObject)
+    err = (<CUresult (*)(CUDA_RESOURCE_DESC*, CUsurfObject) except ?CUDA_ERROR_NOT_FOUND nogil> __cuSurfObjectGetResourceDesc)(pResDesc, surfObject)
     return err
 {{endif}}
 
@@ -11805,7 +11805,7 @@ cdef CUresult _cuDeviceCanAccessPeer(int* canAccessPeer, CUdevice dev, CUdevice
     if __cuDeviceCanAccessPeer == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceCanAccessPeer" not found')
-    err = (<CUresult (*)(int*, CUdevice, CUdevice) nogil> __cuDeviceCanAccessPeer)(canAccessPeer, dev, peerDev)
+    err = (<CUresult (*)(int*, CUdevice, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceCanAccessPeer)(canAccessPeer, dev, peerDev)
     return err
 {{endif}}
 
@@ -11817,7 +11817,7 @@ cdef CUresult _cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags)
     if __cuCtxEnablePeerAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxEnablePeerAccess" not found')
-    err = (<CUresult (*)(CUcontext, unsigned int) nogil> __cuCtxEnablePeerAccess)(peerContext, Flags)
+    err = (<CUresult (*)(CUcontext, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxEnablePeerAccess)(peerContext, Flags)
     return err
 {{endif}}
 
@@ -11829,7 +11829,7 @@ cdef CUresult _cuCtxDisablePeerAccess(CUcontext peerContext) except ?CUDA_ERROR_
     if __cuCtxDisablePeerAccess == NULL:
         with gil:
             raise RuntimeError('Function "cuCtxDisablePeerAccess" not found')
-    err = (<CUresult (*)(CUcontext) nogil> __cuCtxDisablePeerAccess)(peerContext)
+    err = (<CUresult (*)(CUcontext) except ?CUDA_ERROR_NOT_FOUND nogil> __cuCtxDisablePeerAccess)(peerContext)
     return err
 {{endif}}
 
@@ -11841,7 +11841,7 @@ cdef CUresult _cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib,
     if __cuDeviceGetP2PAttribute == NULL:
         with gil:
             raise RuntimeError('Function "cuDeviceGetP2PAttribute" not found')
-    err = (<CUresult (*)(int*, CUdevice_P2PAttribute, CUdevice, CUdevice) nogil> __cuDeviceGetP2PAttribute)(value, attrib, srcDevice, dstDevice)
+    err = (<CUresult (*)(int*, CUdevice_P2PAttribute, CUdevice, CUdevice) except ?CUDA_ERROR_NOT_FOUND nogil> __cuDeviceGetP2PAttribute)(value, attrib, srcDevice, dstDevice)
     return err
 {{endif}}
 
@@ -11853,7 +11853,7 @@ cdef CUresult _cuGraphicsUnregisterResource(CUgraphicsResource resource) except
     if __cuGraphicsUnregisterResource == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsUnregisterResource" not found')
-    err = (<CUresult (*)(CUgraphicsResource) nogil> __cuGraphicsUnregisterResource)(resource)
+    err = (<CUresult (*)(CUgraphicsResource) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsUnregisterResource)(resource)
     return err
 {{endif}}
 
@@ -11865,7 +11865,7 @@ cdef CUresult _cuGraphicsSubResourceGetMappedArray(CUarray* pArray, CUgraphicsRe
     if __cuGraphicsSubResourceGetMappedArray == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsSubResourceGetMappedArray" not found')
-    err = (<CUresult (*)(CUarray*, CUgraphicsResource, unsigned int, unsigned int) nogil> __cuGraphicsSubResourceGetMappedArray)(pArray, resource, arrayIndex, mipLevel)
+    err = (<CUresult (*)(CUarray*, CUgraphicsResource, unsigned int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsSubResourceGetMappedArray)(pArray, resource, arrayIndex, mipLevel)
     return err
 {{endif}}
 
@@ -11877,7 +11877,7 @@ cdef CUresult _cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray* pMipm
     if __cuGraphicsResourceGetMappedMipmappedArray == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsResourceGetMappedMipmappedArray" not found')
-    err = (<CUresult (*)(CUmipmappedArray*, CUgraphicsResource) nogil> __cuGraphicsResourceGetMappedMipmappedArray)(pMipmappedArray, resource)
+    err = (<CUresult (*)(CUmipmappedArray*, CUgraphicsResource) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsResourceGetMappedMipmappedArray)(pMipmappedArray, resource)
     return err
 {{endif}}
 
@@ -11889,7 +11889,7 @@ cdef CUresult _cuGraphicsResourceGetMappedPointer_v2(CUdeviceptr* pDevPtr, size_
     if __cuGraphicsResourceGetMappedPointer_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsResourceGetMappedPointer_v2" not found')
-    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUgraphicsResource) nogil> __cuGraphicsResourceGetMappedPointer_v2)(pDevPtr, pSize, resource)
+    err = (<CUresult (*)(CUdeviceptr*, size_t*, CUgraphicsResource) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsResourceGetMappedPointer_v2)(pDevPtr, pSize, resource)
     return err
 {{endif}}
 
@@ -11901,7 +11901,7 @@ cdef CUresult _cuGraphicsResourceSetMapFlags_v2(CUgraphicsResource resource, uns
     if __cuGraphicsResourceSetMapFlags_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsResourceSetMapFlags_v2" not found')
-    err = (<CUresult (*)(CUgraphicsResource, unsigned int) nogil> __cuGraphicsResourceSetMapFlags_v2)(resource, flags)
+    err = (<CUresult (*)(CUgraphicsResource, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsResourceSetMapFlags_v2)(resource, flags)
     return err
 {{endif}}
 
@@ -11913,7 +11913,7 @@ cdef CUresult _cuGraphicsMapResources(unsigned int count, CUgraphicsResource* re
     if __cuGraphicsMapResources == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsMapResources" not found')
-    err = (<CUresult (*)(unsigned int, CUgraphicsResource*, CUstream) nogil> __cuGraphicsMapResources)(count, resources, hStream)
+    err = (<CUresult (*)(unsigned int, CUgraphicsResource*, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsMapResources)(count, resources, hStream)
     return err
 {{endif}}
 
@@ -11925,7 +11925,7 @@ cdef CUresult _cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource*
     if __cuGraphicsUnmapResources == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsUnmapResources" not found')
-    err = (<CUresult (*)(unsigned int, CUgraphicsResource*, CUstream) nogil> __cuGraphicsUnmapResources)(count, resources, hStream)
+    err = (<CUresult (*)(unsigned int, CUgraphicsResource*, CUstream) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsUnmapResources)(count, resources, hStream)
     return err
 {{endif}}
 
@@ -11937,7 +11937,7 @@ cdef CUresult _cuGetProcAddress(const char* symbol, void** pfn, int cudaVersion,
     if __cuGetProcAddress == NULL:
         with gil:
             raise RuntimeError('Function "cuGetProcAddress" not found')
-    err = (<CUresult (*)(const char*, void**, int, cuuint64_t) nogil> __cuGetProcAddress)(symbol, pfn, cudaVersion, flags)
+    err = (<CUresult (*)(const char*, void**, int, cuuint64_t) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGetProcAddress)(symbol, pfn, cudaVersion, flags)
     return err
 {{endif}}
 
@@ -11949,7 +11949,7 @@ cdef CUresult _cuGetExportTable(const void** ppExportTable, const CUuuid* pExpor
     if __cuGetExportTable == NULL:
         with gil:
             raise RuntimeError('Function "cuGetExportTable" not found')
-    err = (<CUresult (*)(const void**, const CUuuid*) nogil> __cuGetExportTable)(ppExportTable, pExportTableId)
+    err = (<CUresult (*)(const void**, const CUuuid*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGetExportTable)(ppExportTable, pExportTableId)
     return err
 {{endif}}
 
@@ -11961,7 +11961,7 @@ cdef CUresult _cuProfilerInitialize(const char* configFile, const char* outputFi
     if __cuProfilerInitialize == NULL:
         with gil:
             raise RuntimeError('Function "cuProfilerInitialize" not found')
-    err = (<CUresult (*)(const char*, const char*, CUoutput_mode) nogil> __cuProfilerInitialize)(configFile, outputFile, outputMode)
+    err = (<CUresult (*)(const char*, const char*, CUoutput_mode) except ?CUDA_ERROR_NOT_FOUND nogil> __cuProfilerInitialize)(configFile, outputFile, outputMode)
     return err
 {{endif}}
 
@@ -11973,7 +11973,7 @@ cdef CUresult _cuProfilerStart() except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuProfilerStart == NULL:
         with gil:
             raise RuntimeError('Function "cuProfilerStart" not found')
-    err = (<CUresult (*)() nogil> __cuProfilerStart)()
+    err = (<CUresult (*)() except ?CUDA_ERROR_NOT_FOUND nogil> __cuProfilerStart)()
     return err
 {{endif}}
 
@@ -11985,59 +11985,11 @@ cdef CUresult _cuProfilerStop() except ?CUDA_ERROR_NOT_FOUND nogil:
     if __cuProfilerStop == NULL:
         with gil:
             raise RuntimeError('Function "cuProfilerStop" not found')
-    err = (<CUresult (*)() nogil> __cuProfilerStop)()
-    return err
-{{endif}}
-
-{{if True or 'cuVDPAUGetDevice' in found_functions}}
-
-cdef CUresult _cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
-    global __cuVDPAUGetDevice
-    cuPythonInit()
-    if __cuVDPAUGetDevice == NULL:
-        with gil:
-            raise RuntimeError('Function "cuVDPAUGetDevice" not found')
-    err = (<CUresult (*)(CUdevice*, VdpDevice, VdpGetProcAddress*) nogil> __cuVDPAUGetDevice)(pDevice, vdpDevice, vdpGetProcAddress)
-    return err
-{{endif}}
-
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-
-cdef CUresult _cuVDPAUCtxCreate_v2(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
-    global __cuVDPAUCtxCreate_v2
-    cuPythonInit()
-    if __cuVDPAUCtxCreate_v2 == NULL:
-        with gil:
-            raise RuntimeError('Function "cuVDPAUCtxCreate_v2" not found')
-    err = (<CUresult (*)(CUcontext*, unsigned int, CUdevice, VdpDevice, VdpGetProcAddress*) nogil> __cuVDPAUCtxCreate_v2)(pCtx, flags, device, vdpDevice, vdpGetProcAddress)
-    return err
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-cdef CUresult _cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    global __cuGraphicsVDPAURegisterVideoSurface
-    cuPythonInit()
-    if __cuGraphicsVDPAURegisterVideoSurface == NULL:
-        with gil:
-            raise RuntimeError('Function "cuGraphicsVDPAURegisterVideoSurface" not found')
-    err = (<CUresult (*)(CUgraphicsResource*, VdpVideoSurface, unsigned int) nogil> __cuGraphicsVDPAURegisterVideoSurface)(pCudaResource, vdpSurface, flags)
-    return err
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-cdef CUresult _cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    global __cuGraphicsVDPAURegisterOutputSurface
-    cuPythonInit()
-    if __cuGraphicsVDPAURegisterOutputSurface == NULL:
-        with gil:
-            raise RuntimeError('Function "cuGraphicsVDPAURegisterOutputSurface" not found')
-    err = (<CUresult (*)(CUgraphicsResource*, VdpOutputSurface, unsigned int) nogil> __cuGraphicsVDPAURegisterOutputSurface)(pCudaResource, vdpSurface, flags)
+    err = (<CUresult (*)() except ?CUDA_ERROR_NOT_FOUND nogil> __cuProfilerStop)()
     return err
 {{endif}}
 
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGLImageKHR image, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuGraphicsEGLRegisterImage
@@ -12045,11 +11997,11 @@ cdef CUresult _cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGL
     if __cuGraphicsEGLRegisterImage == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsEGLRegisterImage" not found')
-    err = (<CUresult (*)(CUgraphicsResource*, EGLImageKHR, unsigned int) nogil> __cuGraphicsEGLRegisterImage)(pCudaResource, image, flags)
+    err = (<CUresult (*)(CUgraphicsResource*, EGLImageKHR, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsEGLRegisterImage)(pCudaResource, image, flags)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamConsumerConnect
@@ -12057,11 +12009,11 @@ cdef CUresult _cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStream
     if __cuEGLStreamConsumerConnect == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamConsumerConnect" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR) nogil> __cuEGLStreamConsumerConnect)(conn, stream)
+    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamConsumerConnect)(conn, stream)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn, EGLStreamKHR stream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamConsumerConnectWithFlags
@@ -12069,11 +12021,11 @@ cdef CUresult _cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn,
     if __cuEGLStreamConsumerConnectWithFlags == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamConsumerConnectWithFlags" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR, unsigned int) nogil> __cuEGLStreamConsumerConnectWithFlags)(conn, stream, flags)
+    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamConsumerConnectWithFlags)(conn, stream, flags)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamConsumerDisconnect
@@ -12081,11 +12033,11 @@ cdef CUresult _cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except
     if __cuEGLStreamConsumerDisconnect == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamConsumerDisconnect" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*) nogil> __cuEGLStreamConsumerDisconnect)(conn)
+    err = (<CUresult (*)(CUeglStreamConnection*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamConsumerDisconnect)(conn)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgraphicsResource* pCudaResource, CUstream* pStream, unsigned int timeout) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamConsumerAcquireFrame
@@ -12093,11 +12045,11 @@ cdef CUresult _cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgr
     if __cuEGLStreamConsumerAcquireFrame == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamConsumerAcquireFrame" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, CUgraphicsResource*, CUstream*, unsigned int) nogil> __cuEGLStreamConsumerAcquireFrame)(conn, pCudaResource, pStream, timeout)
+    err = (<CUresult (*)(CUeglStreamConnection*, CUgraphicsResource*, CUstream*, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamConsumerAcquireFrame)(conn, pCudaResource, pStream, timeout)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgraphicsResource pCudaResource, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamConsumerReleaseFrame
@@ -12105,11 +12057,11 @@ cdef CUresult _cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgr
     if __cuEGLStreamConsumerReleaseFrame == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamConsumerReleaseFrame" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, CUgraphicsResource, CUstream*) nogil> __cuEGLStreamConsumerReleaseFrame)(conn, pCudaResource, pStream)
+    err = (<CUresult (*)(CUeglStreamConnection*, CUgraphicsResource, CUstream*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamConsumerReleaseFrame)(conn, pCudaResource, pStream)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream, EGLint width, EGLint height) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamProducerConnect
@@ -12117,11 +12069,11 @@ cdef CUresult _cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStream
     if __cuEGLStreamProducerConnect == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamProducerConnect" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR, EGLint, EGLint) nogil> __cuEGLStreamProducerConnect)(conn, stream, width, height)
+    err = (<CUresult (*)(CUeglStreamConnection*, EGLStreamKHR, EGLint, EGLint) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamProducerConnect)(conn, stream, width, height)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamProducerDisconnect
@@ -12129,11 +12081,11 @@ cdef CUresult _cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except
     if __cuEGLStreamProducerDisconnect == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamProducerDisconnect" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*) nogil> __cuEGLStreamProducerDisconnect)(conn)
+    err = (<CUresult (*)(CUeglStreamConnection*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamProducerDisconnect)(conn)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamProducerPresentFrame
@@ -12141,11 +12093,11 @@ cdef CUresult _cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeg
     if __cuEGLStreamProducerPresentFrame == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamProducerPresentFrame" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, CUeglFrame, CUstream*) nogil> __cuEGLStreamProducerPresentFrame)(conn, eglframe, pStream)
+    err = (<CUresult (*)(CUeglStreamConnection*, CUeglFrame, CUstream*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamProducerPresentFrame)(conn, eglframe, pStream)
     return err
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEGLStreamProducerReturnFrame
@@ -12153,11 +12105,11 @@ cdef CUresult _cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUegl
     if __cuEGLStreamProducerReturnFrame == NULL:
         with gil:
             raise RuntimeError('Function "cuEGLStreamProducerReturnFrame" not found')
-    err = (<CUresult (*)(CUeglStreamConnection*, CUeglFrame*, CUstream*) nogil> __cuEGLStreamProducerReturnFrame)(conn, eglframe, pStream)
+    err = (<CUresult (*)(CUeglStreamConnection*, CUeglFrame*, CUstream*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEGLStreamProducerReturnFrame)(conn, eglframe, pStream)
     return err
 {{endif}}
 
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraphicsResource resource, unsigned int index, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuGraphicsResourceGetMappedEglFrame
@@ -12165,11 +12117,11 @@ cdef CUresult _cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraph
     if __cuGraphicsResourceGetMappedEglFrame == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsResourceGetMappedEglFrame" not found')
-    err = (<CUresult (*)(CUeglFrame*, CUgraphicsResource, unsigned int, unsigned int) nogil> __cuGraphicsResourceGetMappedEglFrame)(eglFrame, resource, index, mipLevel)
+    err = (<CUresult (*)(CUeglFrame*, CUgraphicsResource, unsigned int, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsResourceGetMappedEglFrame)(eglFrame, resource, index, mipLevel)
     return err
 {{endif}}
 
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuEventCreateFromEGLSync
@@ -12177,11 +12129,11 @@ cdef CUresult _cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, un
     if __cuEventCreateFromEGLSync == NULL:
         with gil:
             raise RuntimeError('Function "cuEventCreateFromEGLSync" not found')
-    err = (<CUresult (*)(CUevent*, EGLSyncKHR, unsigned int) nogil> __cuEventCreateFromEGLSync)(phEvent, eglSync, flags)
+    err = (<CUresult (*)(CUevent*, EGLSyncKHR, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuEventCreateFromEGLSync)(phEvent, eglSync, flags)
     return err
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuGraphicsGLRegisterBuffer
@@ -12189,11 +12141,11 @@ cdef CUresult _cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLu
     if __cuGraphicsGLRegisterBuffer == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsGLRegisterBuffer" not found')
-    err = (<CUresult (*)(CUgraphicsResource*, GLuint, unsigned int) nogil> __cuGraphicsGLRegisterBuffer)(pCudaResource, buffer, Flags)
+    err = (<CUresult (*)(CUgraphicsResource*, GLuint, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsGLRegisterBuffer)(pCudaResource, buffer, Flags)
     return err
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuGraphicsGLRegisterImage
@@ -12201,11 +12153,11 @@ cdef CUresult _cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLui
     if __cuGraphicsGLRegisterImage == NULL:
         with gil:
             raise RuntimeError('Function "cuGraphicsGLRegisterImage" not found')
-    err = (<CUresult (*)(CUgraphicsResource*, GLuint, GLenum, unsigned int) nogil> __cuGraphicsGLRegisterImage)(pCudaResource, image, target, Flags)
+    err = (<CUresult (*)(CUgraphicsResource*, GLuint, GLenum, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsGLRegisterImage)(pCudaResource, image, target, Flags)
     return err
 {{endif}}
 
-{{if True or 'cuGLGetDevices_v2' in found_functions}}
+{{if True}}
 
 cdef CUresult _cuGLGetDevices_v2(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil:
     global __cuGLGetDevices_v2
@@ -12213,6 +12165,54 @@ cdef CUresult _cuGLGetDevices_v2(unsigned int* pCudaDeviceCount, CUdevice* pCuda
     if __cuGLGetDevices_v2 == NULL:
         with gil:
             raise RuntimeError('Function "cuGLGetDevices_v2" not found')
-    err = (<CUresult (*)(unsigned int*, CUdevice*, unsigned int, CUGLDeviceList) nogil> __cuGLGetDevices_v2)(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+    err = (<CUresult (*)(unsigned int*, CUdevice*, unsigned int, CUGLDeviceList) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGLGetDevices_v2)(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+    return err
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
+    global __cuVDPAUGetDevice
+    cuPythonInit()
+    if __cuVDPAUGetDevice == NULL:
+        with gil:
+            raise RuntimeError('Function "cuVDPAUGetDevice" not found')
+    err = (<CUresult (*)(CUdevice*, VdpDevice, VdpGetProcAddress*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuVDPAUGetDevice)(pDevice, vdpDevice, vdpGetProcAddress)
+    return err
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuVDPAUCtxCreate_v2(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
+    global __cuVDPAUCtxCreate_v2
+    cuPythonInit()
+    if __cuVDPAUCtxCreate_v2 == NULL:
+        with gil:
+            raise RuntimeError('Function "cuVDPAUCtxCreate_v2" not found')
+    err = (<CUresult (*)(CUcontext*, unsigned int, CUdevice, VdpDevice, VdpGetProcAddress*) except ?CUDA_ERROR_NOT_FOUND nogil> __cuVDPAUCtxCreate_v2)(pCtx, flags, device, vdpDevice, vdpGetProcAddress)
+    return err
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
+    global __cuGraphicsVDPAURegisterVideoSurface
+    cuPythonInit()
+    if __cuGraphicsVDPAURegisterVideoSurface == NULL:
+        with gil:
+            raise RuntimeError('Function "cuGraphicsVDPAURegisterVideoSurface" not found')
+    err = (<CUresult (*)(CUgraphicsResource*, VdpVideoSurface, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsVDPAURegisterVideoSurface)(pCudaResource, vdpSurface, flags)
+    return err
+{{endif}}
+
+{{if True}}
+
+cdef CUresult _cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
+    global __cuGraphicsVDPAURegisterOutputSurface
+    cuPythonInit()
+    if __cuGraphicsVDPAURegisterOutputSurface == NULL:
+        with gil:
+            raise RuntimeError('Function "cuGraphicsVDPAURegisterOutputSurface" not found')
+    err = (<CUresult (*)(CUgraphicsResource*, VdpOutputSurface, unsigned int) except ?CUDA_ERROR_NOT_FOUND nogil> __cuGraphicsVDPAURegisterOutputSurface)(pCudaResource, vdpSurface, flags)
     return err
 {{endif}}
diff --git a/cuda/_cuda/cnvrtc.pxd.in b/cuda/cuda/bindings/_bindings/cynvrtc.pxd.in
similarity index 96%
rename from cuda/_cuda/cnvrtc.pxd.in
rename to cuda/cuda/bindings/_bindings/cynvrtc.pxd.in
index 027bc2d0..bc7f49d3 100644
--- a/cuda/_cuda/cnvrtc.pxd.in
+++ b/cuda/cuda/bindings/_bindings/cynvrtc.pxd.in
@@ -1,11 +1,11 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-from cuda.cnvrtc cimport *
+from cuda.bindings.cynvrtc cimport *
 
 {{if 'nvrtcGetErrorString' in found_functions}}
 
@@ -91,3 +91,4 @@ cdef nvrtcResult _nvrtcAddNameExpression(nvrtcProgram prog, const char* name_exp
 
 cdef nvrtcResult _nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expression, const char** lowered_name) except ?NVRTC_ERROR_INVALID_INPUT nogil
 {{endif}}
+
diff --git a/cuda/_cuda/cnvrtc.pyx.in b/cuda/cuda/bindings/_bindings/cynvrtc.pyx.in
similarity index 88%
rename from cuda/_cuda/cnvrtc.pyx.in
rename to cuda/cuda/bindings/_bindings/cynvrtc.pyx.in
index fb7a9f93..bd5e14d0 100644
--- a/cuda/_cuda/cnvrtc.pyx.in
+++ b/cuda/cuda/bindings/_bindings/cynvrtc.pyx.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -10,7 +10,7 @@ import win32api
 import struct
 from pywintypes import error
 {{else}}
-cimport cuda._lib.dlfcn as dlfcn
+cimport cuda.bindings._lib.dlfcn as dlfcn
 {{endif}}
 
 cdef bint __cuPythonInit = False
@@ -269,7 +269,7 @@ cdef const char* _nvrtcGetErrorString(nvrtcResult result) except ?NULL nogil:
     if __nvrtcGetErrorString == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetErrorString" not found')
-    err = (<const char* (*)(nvrtcResult) nogil> __nvrtcGetErrorString)(result)
+    err = (<const char* (*)(nvrtcResult) except ?NULL nogil> __nvrtcGetErrorString)(result)
     return err
 {{endif}}
 
@@ -281,7 +281,7 @@ cdef nvrtcResult _nvrtcVersion(int* major, int* minor) except ?NVRTC_ERROR_INVAL
     if __nvrtcVersion == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcVersion" not found')
-    err = (<nvrtcResult (*)(int*, int*) nogil> __nvrtcVersion)(major, minor)
+    err = (<nvrtcResult (*)(int*, int*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcVersion)(major, minor)
     return err
 {{endif}}
 
@@ -293,7 +293,7 @@ cdef nvrtcResult _nvrtcGetNumSupportedArchs(int* numArchs) except ?NVRTC_ERROR_I
     if __nvrtcGetNumSupportedArchs == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetNumSupportedArchs" not found')
-    err = (<nvrtcResult (*)(int*) nogil> __nvrtcGetNumSupportedArchs)(numArchs)
+    err = (<nvrtcResult (*)(int*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetNumSupportedArchs)(numArchs)
     return err
 {{endif}}
 
@@ -305,7 +305,7 @@ cdef nvrtcResult _nvrtcGetSupportedArchs(int* supportedArchs) except ?NVRTC_ERRO
     if __nvrtcGetSupportedArchs == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetSupportedArchs" not found')
-    err = (<nvrtcResult (*)(int*) nogil> __nvrtcGetSupportedArchs)(supportedArchs)
+    err = (<nvrtcResult (*)(int*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetSupportedArchs)(supportedArchs)
     return err
 {{endif}}
 
@@ -317,7 +317,7 @@ cdef nvrtcResult _nvrtcCreateProgram(nvrtcProgram* prog, const char* src, const
     if __nvrtcCreateProgram == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcCreateProgram" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram*, const char*, const char*, int, const char**, const char**) nogil> __nvrtcCreateProgram)(prog, src, name, numHeaders, headers, includeNames)
+    err = (<nvrtcResult (*)(nvrtcProgram*, const char*, const char*, int, const char**, const char**) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcCreateProgram)(prog, src, name, numHeaders, headers, includeNames)
     return err
 {{endif}}
 
@@ -329,7 +329,7 @@ cdef nvrtcResult _nvrtcDestroyProgram(nvrtcProgram* prog) except ?NVRTC_ERROR_IN
     if __nvrtcDestroyProgram == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcDestroyProgram" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram*) nogil> __nvrtcDestroyProgram)(prog)
+    err = (<nvrtcResult (*)(nvrtcProgram*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcDestroyProgram)(prog)
     return err
 {{endif}}
 
@@ -341,7 +341,7 @@ cdef nvrtcResult _nvrtcCompileProgram(nvrtcProgram prog, int numOptions, const c
     if __nvrtcCompileProgram == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcCompileProgram" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, int, const char**) nogil> __nvrtcCompileProgram)(prog, numOptions, options)
+    err = (<nvrtcResult (*)(nvrtcProgram, int, const char**) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcCompileProgram)(prog, numOptions, options)
     return err
 {{endif}}
 
@@ -353,7 +353,7 @@ cdef nvrtcResult _nvrtcGetPTXSize(nvrtcProgram prog, size_t* ptxSizeRet) except
     if __nvrtcGetPTXSize == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetPTXSize" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) nogil> __nvrtcGetPTXSize)(prog, ptxSizeRet)
+    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetPTXSize)(prog, ptxSizeRet)
     return err
 {{endif}}
 
@@ -365,7 +365,7 @@ cdef nvrtcResult _nvrtcGetPTX(nvrtcProgram prog, char* ptx) except ?NVRTC_ERROR_
     if __nvrtcGetPTX == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetPTX" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, char*) nogil> __nvrtcGetPTX)(prog, ptx)
+    err = (<nvrtcResult (*)(nvrtcProgram, char*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetPTX)(prog, ptx)
     return err
 {{endif}}
 
@@ -377,7 +377,7 @@ cdef nvrtcResult _nvrtcGetCUBINSize(nvrtcProgram prog, size_t* cubinSizeRet) exc
     if __nvrtcGetCUBINSize == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetCUBINSize" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) nogil> __nvrtcGetCUBINSize)(prog, cubinSizeRet)
+    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetCUBINSize)(prog, cubinSizeRet)
     return err
 {{endif}}
 
@@ -389,7 +389,7 @@ cdef nvrtcResult _nvrtcGetCUBIN(nvrtcProgram prog, char* cubin) except ?NVRTC_ER
     if __nvrtcGetCUBIN == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetCUBIN" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, char*) nogil> __nvrtcGetCUBIN)(prog, cubin)
+    err = (<nvrtcResult (*)(nvrtcProgram, char*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetCUBIN)(prog, cubin)
     return err
 {{endif}}
 
@@ -401,7 +401,7 @@ cdef nvrtcResult _nvrtcGetNVVMSize(nvrtcProgram prog, size_t* nvvmSizeRet) excep
     if __nvrtcGetNVVMSize == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetNVVMSize" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) nogil> __nvrtcGetNVVMSize)(prog, nvvmSizeRet)
+    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetNVVMSize)(prog, nvvmSizeRet)
     return err
 {{endif}}
 
@@ -413,7 +413,7 @@ cdef nvrtcResult _nvrtcGetNVVM(nvrtcProgram prog, char* nvvm) except ?NVRTC_ERRO
     if __nvrtcGetNVVM == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetNVVM" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, char*) nogil> __nvrtcGetNVVM)(prog, nvvm)
+    err = (<nvrtcResult (*)(nvrtcProgram, char*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetNVVM)(prog, nvvm)
     return err
 {{endif}}
 
@@ -425,7 +425,7 @@ cdef nvrtcResult _nvrtcGetProgramLogSize(nvrtcProgram prog, size_t* logSizeRet)
     if __nvrtcGetProgramLogSize == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetProgramLogSize" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) nogil> __nvrtcGetProgramLogSize)(prog, logSizeRet)
+    err = (<nvrtcResult (*)(nvrtcProgram, size_t*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetProgramLogSize)(prog, logSizeRet)
     return err
 {{endif}}
 
@@ -437,7 +437,7 @@ cdef nvrtcResult _nvrtcGetProgramLog(nvrtcProgram prog, char* log) except ?NVRTC
     if __nvrtcGetProgramLog == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetProgramLog" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, char*) nogil> __nvrtcGetProgramLog)(prog, log)
+    err = (<nvrtcResult (*)(nvrtcProgram, char*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetProgramLog)(prog, log)
     return err
 {{endif}}
 
@@ -449,7 +449,7 @@ cdef nvrtcResult _nvrtcAddNameExpression(nvrtcProgram prog, const char* name_exp
     if __nvrtcAddNameExpression == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcAddNameExpression" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, const char*) nogil> __nvrtcAddNameExpression)(prog, name_expression)
+    err = (<nvrtcResult (*)(nvrtcProgram, const char*) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcAddNameExpression)(prog, name_expression)
     return err
 {{endif}}
 
@@ -461,6 +461,6 @@ cdef nvrtcResult _nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expres
     if __nvrtcGetLoweredName == NULL:
         with gil:
             raise RuntimeError('Function "nvrtcGetLoweredName" not found')
-    err = (<nvrtcResult (*)(nvrtcProgram, const char*, const char**) nogil> __nvrtcGetLoweredName)(prog, name_expression, lowered_name)
+    err = (<nvrtcResult (*)(nvrtcProgram, const char*, const char**) except ?NVRTC_ERROR_INVALID_INPUT nogil> __nvrtcGetLoweredName)(prog, name_expression, lowered_name)
     return err
 {{endif}}
diff --git a/cuda/_cuda/loader.cpp b/cuda/cuda/bindings/_bindings/loader.cpp
similarity index 99%
rename from cuda/_cuda/loader.cpp
rename to cuda/cuda/bindings/_bindings/loader.cpp
index 8cc001e2..b2477fef 100644
--- a/cuda/_cuda/loader.cpp
+++ b/cuda/cuda/bindings/_bindings/loader.cpp
@@ -1,4 +1,4 @@
-// Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+// Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 //
 // Please refer to the NVIDIA end user license agreement (EULA) associated
 // with this source code for terms and conditions that govern your use of
diff --git a/cuda/_cuda/loader.h b/cuda/cuda/bindings/_bindings/loader.h
similarity index 100%
rename from cuda/_cuda/loader.h
rename to cuda/cuda/bindings/_bindings/loader.h
diff --git a/cuda/_cuda/loader.pxd b/cuda/cuda/bindings/_bindings/loader.pxd
similarity index 100%
rename from cuda/_cuda/loader.pxd
rename to cuda/cuda/bindings/_bindings/loader.pxd
diff --git a/cuda/_lib/ccudart/__init__.py b/cuda/cuda/bindings/_lib/__init__.py
similarity index 100%
rename from cuda/_lib/ccudart/__init__.py
rename to cuda/cuda/bindings/_lib/__init__.py
diff --git a/cuda/benchmarks/__init__.py b/cuda/cuda/bindings/_lib/cyruntime/__init__.py
similarity index 100%
rename from cuda/benchmarks/__init__.py
rename to cuda/cuda/bindings/_lib/cyruntime/__init__.py
diff --git a/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pxd.in b/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pxd.in
new file mode 100644
index 00000000..57f7735f
--- /dev/null
+++ b/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pxd.in
@@ -0,0 +1,297 @@
+# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+cimport cuda.bindings.cydriver as cydriver
+from cuda.bindings.cyruntime cimport *
+from libc.stdlib cimport malloc, free, calloc
+from libc.string cimport memset, memcpy, strncmp
+from libcpp cimport bool
+
+{{if 'cudaMemcpy' in found_functions}}cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamCreate' in found_functions}}cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventCreate' in found_functions}}cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventQuery' in found_functions}}cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaCreateChannelDesc' in found_functions}}cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) noexcept nogil{{endif}}
+{{if 'cudaDriverGetVersion' in found_functions}}cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaRuntimeGetVersion' in found_functions}}cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocHost' in found_functions}}cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocPitch' in found_functions}}cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocMipmappedArray' in found_functions}}cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2D' in found_functions}}cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyAsync' in found_functions}}cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddMemcpyNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetDriverEntryPoint' in found_functions}}cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddMemsetNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFuncGetAttributes' in found_functions}}cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocArray' in found_functions}}cdef cudaError_t _cudaMallocArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMalloc3D' in found_functions}}cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMalloc3DArray' in found_functions}}cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetErrorString' in found_functions}}cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil{{endif}}
+{{if 'cudaStreamAddCallback' in found_functions}}cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamGetCaptureInfo' in found_functions}}cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}cdef cudaError_t _cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaImportExternalSemaphore' in found_functions}}cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaArrayGetInfo' in found_functions}}cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DToArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DFromArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DArrayToArray' in found_functions}}cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DToArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemset3D' in found_functions}}cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemset3DAsync' in found_functions}}cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyToArray' in found_functions}}cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyFromArray' in found_functions}}cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyToArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyFromArrayAsync' in found_functions}}cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaPointerGetAttributes' in found_functions}}cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetDeviceFlags' in found_functions}}cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy3D' in found_functions}}cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy3DAsync' in found_functions}}cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolSetAccess' in found_functions}}cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceReset' in found_functions}}cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaThreadExit' in found_functions}}cdef cudaError_t _cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetLastError' in found_functions}}cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaPeekAtLastError' in found_functions}}cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetDevice' in found_functions}}cdef cudaError_t _cudaGetDevice(int* device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaSetDevice' in found_functions}}cdef cudaError_t _cudaSetDevice(int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetDeviceProperties' in found_functions}}cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaChooseDevice' in found_functions}}cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyArrayToArray' in found_functions}}cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetChannelDesc' in found_functions}}cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaCreateTextureObject' in found_functions}}cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaCreateTextureObject_v2' in found_functions}}cdef cudaError_t _cudaCreateTextureObject_v2(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc_v2* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}cdef cudaError_t _cudaGetTextureObjectTextureDesc_v2(cudaTextureDesc_v2* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetExportTable' in found_functions}}cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy3DPeer' in found_functions}}cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpy3DPeerAsync' in found_functions}}cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'make_cudaPitchedPtr' in found_functions}}cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) noexcept nogil{{endif}}
+{{if 'make_cudaPos' in found_functions}}cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) noexcept nogil{{endif}}
+{{if 'make_cudaExtent' in found_functions}}cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) noexcept nogil{{endif}}
+{{if 'cudaSetDoubleForDevice' in found_functions}}cdef cudaError_t _cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaSetDoubleForHost' in found_functions}}cdef cudaError_t _cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaSetDeviceFlags' in found_functions}}cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddMemAllocNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemAdvise' in found_functions}}cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemRangeGetAttribute' in found_functions}}cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemRangeGetAttributes' in found_functions}}cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetDeviceCount' in found_functions}}cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetAttribute' in found_functions}}cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetByPCIBusId' in found_functions}}cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetPCIBusId' in found_functions}}cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetP2PAttribute' in found_functions}}cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaArrayGetSparseProperties' in found_functions}}cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceCanAccessPeer' in found_functions}}cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyPeer' in found_functions}}cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemcpyPeerAsync' in found_functions}}cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceEnablePeerAccess' in found_functions}}cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceDisablePeerAccess' in found_functions}}cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphKernelNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaImportExternalMemory' in found_functions}}cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaCreateSurfaceObject' in found_functions}}cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaArrayGetMemoryRequirements' in found_functions}}cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamGetAttribute' in found_functions}}cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamSetAttribute' in found_functions}}cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSynchronize' in found_functions}}cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSetLimit' in found_functions}}cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetLimit' in found_functions}}cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetCacheConfig' in found_functions}}cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSetCacheConfig' in found_functions}}cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetSharedMemConfig' in found_functions}}cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaIpcGetEventHandle' in found_functions}}cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaIpcOpenEventHandle' in found_functions}}cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaIpcGetMemHandle' in found_functions}}cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaIpcOpenMemHandle' in found_functions}}cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaIpcCloseMemHandle' in found_functions}}cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaThreadSynchronize' in found_functions}}cdef cudaError_t _cudaThreadSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaThreadSetLimit' in found_functions}}cdef cudaError_t _cudaThreadSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaThreadGetLimit' in found_functions}}cdef cudaError_t _cudaThreadGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetDefaultMemPool' in found_functions}}cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSetMemPool' in found_functions}}cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetMemPool' in found_functions}}cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}}cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamCreateWithFlags' in found_functions}}cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamCreateWithPriority' in found_functions}}cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamGetPriority' in found_functions}}cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamGetFlags' in found_functions}}cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaCtxResetPersistingL2Cache' in found_functions}}cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamCopyAttributes' in found_functions}}cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamDestroy' in found_functions}}cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamWaitEvent' in found_functions}}cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamSynchronize' in found_functions}}cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamQuery' in found_functions}}cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamAttachMemAsync' in found_functions}}cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamBeginCapture' in found_functions}}cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}}cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamEndCapture' in found_functions}}cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamIsCapturing' in found_functions}}cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventCreateWithFlags' in found_functions}}cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventRecord' in found_functions}}cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventRecordWithFlags' in found_functions}}cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventSynchronize' in found_functions}}cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventDestroy' in found_functions}}cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaEventElapsedTime' in found_functions}}cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDestroyExternalMemory' in found_functions}}cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDestroyExternalSemaphore' in found_functions}}cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFuncSetCacheConfig' in found_functions}}cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFuncSetSharedMemConfig' in found_functions}}cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFuncSetAttribute' in found_functions}}cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaLaunchHostFunc' in found_functions}}cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}}cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocManaged' in found_functions}}cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMalloc' in found_functions}}cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFree' in found_functions}}cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFreeHost' in found_functions}}cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFreeArray' in found_functions}}cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFreeMipmappedArray' in found_functions}}cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaHostAlloc' in found_functions}}cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaHostRegister' in found_functions}}cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaHostUnregister' in found_functions}}cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaHostGetDevicePointer' in found_functions}}cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaHostGetFlags' in found_functions}}cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGetMipmappedArrayLevel' in found_functions}}cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemGetInfo' in found_functions}}cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaArrayGetPlane' in found_functions}}cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemset' in found_functions}}cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemset2D' in found_functions}}cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemsetAsync' in found_functions}}cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemset2DAsync' in found_functions}}cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPrefetchAsync' in found_functions}}cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocAsync' in found_functions}}cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaFreeAsync' in found_functions}}cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolTrimTo' in found_functions}}cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolSetAttribute' in found_functions}}cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolGetAttribute' in found_functions}}cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolGetAccess' in found_functions}}cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolCreate' in found_functions}}cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolDestroy' in found_functions}}cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMallocFromPoolAsync' in found_functions}}cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolExportToShareableHandle' in found_functions}}cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolExportPointer' in found_functions}}cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaMemPoolImportPointer' in found_functions}}cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsUnregisterResource' in found_functions}}cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}}cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsMapResources' in found_functions}}cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsUnmapResources' in found_functions}}cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}}cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}}cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}}cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDestroyTextureObject' in found_functions}}cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDestroySurfaceObject' in found_functions}}cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphCreate' in found_functions}}cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddKernelNode' in found_functions}}cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphKernelNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemsetNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphMemsetNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddHostNode' in found_functions}}cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphHostNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphHostNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddChildGraphNode' in found_functions}}cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddEmptyNode' in found_functions}}cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddEventRecordNode' in found_functions}}cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddEventWaitNode' in found_functions}}cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddMemFreeNode' in found_functions}}cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGraphMemTrim' in found_functions}}cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphClone' in found_functions}}cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeFindInClone' in found_functions}}cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeGetType' in found_functions}}cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphGetNodes' in found_functions}}cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphGetRootNodes' in found_functions}}cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphGetEdges' in found_functions}}cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeGetDependencies' in found_functions}}cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeGetDependentNodes' in found_functions}}cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphAddDependencies' in found_functions}}cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphRemoveDependencies' in found_functions}}cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphDestroyNode' in found_functions}}cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphInstantiate' in found_functions}}cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphInstantiateWithFlags' in found_functions}}cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecHostNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeSetEnabled' in found_functions}}cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphNodeGetEnabled' in found_functions}}cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecUpdate' in found_functions}}cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t* hErrorNode_out, cudaGraphExecUpdateResult* updateResult_out) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphUpload' in found_functions}}cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphLaunch' in found_functions}}cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphExecDestroy' in found_functions}}cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphDestroy' in found_functions}}cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphDebugDotPrint' in found_functions}}cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaUserObjectCreate' in found_functions}}cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaUserObjectRetain' in found_functions}}cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaUserObjectRelease' in found_functions}}cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphRetainUserObject' in found_functions}}cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if 'cudaGraphReleaseUserObject' in found_functions}}cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
+{{if True}}cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil{{endif}}
diff --git a/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pyx.in b/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pyx.in
new file mode 100644
index 00000000..e7d88af1
--- /dev/null
+++ b/cuda/cuda/bindings/_lib/cyruntime/cyruntime.pyx.in
@@ -0,0 +1,4725 @@
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
+#
+# Please refer to the NVIDIA end user license agreement (EULA) associated
+# with this source code for terms and conditions that govern your use of
+# this software. Any use, reproduction, disclosure, or distribution of
+# this software and related documentation outside the terms of the EULA
+# is strictly prohibited.
+from cuda.bindings.cyruntime cimport *
+from cuda.bindings._lib.cyruntime.utils cimport *
+from libc.stdlib cimport malloc, free, calloc
+from libc.string cimport memset, memcpy, strncmp
+from libcpp cimport bool
+cimport cuda.bindings._bindings.cydriver as cydriver
+{{if 'Windows' != platform.system()}}
+cimport cuda.bindings._lib.dlfcn as dlfcn
+{{endif}}
+
+cdef cudaPythonGlobal m_global = globalGetInstance()
+
+{{if 'cudaMemcpy' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyDispatch(dst, src, count, kind)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaStreamCreate' in found_functions}}
+
+cdef cudaError_t _cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamCreate(pStream, 0)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaEventCreate' in found_functions}}
+
+cdef cudaError_t _cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventCreate(event, cydriver.CUevent_flags_enum.CU_EVENT_DEFAULT)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaEventQuery' in found_functions}}
+
+cdef cudaError_t _cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuEventQuery(<cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaCreateChannelDesc' in found_functions}}
+
+cdef cudaChannelFormatDesc _cudaCreateChannelDesc(int x, int y, int z, int w, cudaChannelFormatKind f) noexcept nogil:
+    cdef cudaChannelFormatDesc desc
+    desc.x = x
+    desc.y = y
+    desc.z = z
+    desc.w = w
+    desc.f = f
+    return desc
+
+
+{{endif}}
+{{if 'cudaDriverGetVersion' in found_functions}}
+
+cdef cudaError_t _cudaDriverGetVersion(int* driverVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuDriverGetVersion(driverVersion)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaRuntimeGetVersion' in found_functions}}
+
+cdef cudaError_t _cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    runtimeVersion[0] = m_global._CUDART_VERSION
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, const cudaChannelFormatDesc* fmtDesc, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if fmtDesc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUarray_format fmt
+    cdef int numChannels = 0
+
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    err = getDescInfo(fmtDesc, &numChannels, &fmt)
+    if err == cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, fmt, <unsigned>numChannels, device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMallocHost' in found_functions}}
+
+cdef cudaError_t _cudaMallocHost(void** ptr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if ptr == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocHost(size, ptr, 0)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMallocPitch' in found_functions}}
+
+cdef cudaError_t _cudaMallocPitch(void** devPtr, size_t* pitch, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if devPtr == NULL or pitch == NULL:
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocPitch(width, height, 1, devPtr, pitch)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMallocMipmappedArray' in found_functions}}
+
+cdef cudaError_t _cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int numLevels, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if mipmappedArray == NULL or desc == NULL:
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocMipmappedArray(mipmappedArray, desc, extent.depth, extent.height, extent.width, numLevels, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2D' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DPtr(<char*>dst, dpitch, <const char*>src, spitch, width, height, kind, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2DAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DPtr(<char*>dst, dpitch, <const char*>src, spitch, width, height, kind, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyAsync(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyAsyncDispatch(dst, src, count, kind, stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphAddMemcpyNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddMemcpyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemcpy3DParms* pCopyParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaError_t err = cudaSuccess
+
+    if pCopyParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = toDriverMemCopy3DParams(pCopyParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, &driverNodeParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddMemcpyNode1D(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaMemcpy3DParms copyParams
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
+
+    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuGraphAddMemcpyNode(pGraphNode, graph, pDependencies, numDependencies, &driverNodeParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemcpyNodeSetParams1D(cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaMemcpy3DParms copyParams
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
+
+    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuGraphMemcpyNodeSetParams(node, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaError_t err = cudaSuccess
+
+    if pNodeParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = toDriverMemCopy3DParams(pNodeParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuGraphExecMemcpyNodeSetParams(hGraphExec, node, &driverNodeParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecMemcpyNodeSetParams1D(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, void* dst, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaMemcpy3DParms copyParams
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    copy1DConvertTo3DParams(dst, src, count, kind, &copyParams)
+
+    err = toDriverMemCopy3DParams(&copyParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuGraphExecMemcpyNodeSetParams(hGraphExec, node, &driverNodeParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGetDriverEntryPoint' in found_functions}}
+
+cdef cudaError_t _cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuGetProcAddress(symbol, funcPtr, m_global._CUDART_VERSION, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphAddMemsetNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaMemsetParams* pMemsetParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS driverParams
+    cdef cudaError_t err = cudaSuccess
+
+    if pMemsetParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    toDriverMemsetNodeParams(pMemsetParams, &driverParams)
+
+    err = <cudaError_t>cydriver._cuGraphAddMemsetNode(pGraphNode, graph, pDependencies, numDependencies, &driverParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUcontext context
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS driverParams
+    cdef cudaError_t err = cudaSuccess
+
+    if pNodeParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    toDriverMemsetNodeParams(pNodeParams, &driverParams)
+
+    err = <cudaError_t>cydriver._cuGraphExecMemsetNodeSetParams(hGraphExec, node, &driverParams, context)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemcpyNodeSetParams(cudaGraphNode_t node, const cudaMemcpy3DParms* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+    cdef cudaError_t err = cudaSuccess
+
+    if pNodeParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = toDriverMemCopy3DParams(pNodeParams, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemcpyNodeSetParams(node, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemcpyNodeGetParams(cudaGraphNode_t node, cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cydriver.CUDA_MEMCPY3D_v2 driverNodeParams
+
+    if p == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemcpyNodeGetParams(node, &driverNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = toCudartMemCopy3DParams(&driverNodeParams, p)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaFuncGetAttributes' in found_functions}}
+
+cdef cudaError_t _cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* func) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if NULL == attr:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    cdef int bytes = 0
+    memset(attr, 0, sizeof(cudaFuncAttributes))
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].maxThreadsPerBlock,     cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].numRegs,                cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NUM_REGS, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].ptxVersion,             cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PTX_VERSION, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].binaryVersion,          cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_BINARY_VERSION, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&bytes,                          cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    attr[0].sharedSizeBytes = <size_t>bytes
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&bytes,                          cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    attr[0].constSizeBytes = <size_t>bytes
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&bytes,                          cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    attr[0].localSizeBytes = <size_t>bytes
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].cacheModeCA,            cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CACHE_MODE_CA, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&bytes,                          cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuFuncGetAttribute(&attr[0].preferredShmemCarveout, cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT, <cydriver.CUfunction>func)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    attr[0].maxDynamicSharedSizeBytes = <size_t>bytes
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMallocArray' in found_functions}}
+
+cdef cudaError_t _cudaMallocArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, size_t width, size_t height, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if arrayPtr == NULL or desc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocArray(arrayPtr, desc, 0, height, width, 0, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMalloc3D' in found_functions}}
+
+cdef cudaError_t _cudaMalloc3D(cudaPitchedPtr* pitchedDevPtr, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if pitchedDevPtr == NULL:
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocPitch(extent.width, extent.height, extent.depth, &pitchedDevPtr[0].ptr, &pitchedDevPtr[0].pitch)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    pitchedDevPtr[0].xsize = extent.width
+    pitchedDevPtr[0].ysize = extent.height
+    return err
+
+
+{{endif}}
+{{if 'cudaMalloc3DArray' in found_functions}}
+
+cdef cudaError_t _cudaMalloc3DArray(cudaArray_t* arrayPtr, const cudaChannelFormatDesc* desc, cudaExtent extent, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if arrayPtr == NULL or desc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = mallocArray(arrayPtr, desc, extent.depth, extent.height, extent.width, 0, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGetErrorString' in found_functions}}
+
+cdef const char* _cudaGetErrorString(cudaError_t error) except ?NULL nogil:
+    cdef const char* pStr = NULL
+    cdef cudaError_t err = cudaSuccess
+
+    err = <cudaError_t>cydriver._cuGetErrorString(<cydriver.CUresult>error, &pStr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    if err == <cudaError_t>cudaErrorInvalidValue:
+        pStr = "unrecognized error code"
+    return pStr
+
+
+{{endif}}
+{{if 'cudaStreamAddCallback' in found_functions}}
+
+cdef cudaError_t _cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t callback, void* userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = streamAddCallbackCommon(stream, callback, userData, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaStreamGetCaptureInfo' in found_functions}}
+
+cdef cudaError_t _cudaStreamGetCaptureInfo(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = streamGetCaptureInfoCommon(stream, captureStatus_out, id_out, <cudaGraph_t *>0, <const cudaGraphNode_t **>0, <size_t *>0)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaStreamGetCaptureInfo_v2' in found_functions}}
+
+cdef cudaError_t _cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long* id_out, cudaGraph_t* graph_out, const cudaGraphNode_t** dependencies_out, size_t* numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = streamGetCaptureInfoCommon(stream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaImportExternalSemaphore' in found_functions}}
+
+cdef cudaError_t _cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out, const cudaExternalSemaphoreHandleDesc* semHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC driverSemHandleDesc
+
+    if semHandleDesc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    memset(&driverSemHandleDesc, 0, sizeof(driverSemHandleDesc))
+
+    if semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD
+        driverSemHandleDesc.handle.fd = semHandleDesc.handle.fd
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC
+        driverSemHandleDesc.handle.nvSciSyncObj = semHandleDesc.handle.nvSciSyncObj
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD
+        driverSemHandleDesc.handle.fd = semHandleDesc.handle.fd
+    elif semHandleDesc.type == cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32:
+        driverSemHandleDesc.type =  cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32
+        driverSemHandleDesc.handle.win32.handle = semHandleDesc.handle.win32.handle
+        driverSemHandleDesc.handle.win32.name = semHandleDesc.handle.win32.name
+    driverSemHandleDesc.flags = semHandleDesc.flags
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuImportExternalSemaphore(<cydriver.CUexternalSemaphore *>extSem_out, &driverSemHandleDesc)
+    if err != <cudaError_t>cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}
+
+cdef cudaError_t _cudaSignalExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuSignalExternalSemaphoresAsync(<const cydriver.CUexternalSemaphore *>extSemArray, <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS *>paramsArray, numExtSems, stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}
+
+cdef cudaError_t _cudaWaitExternalSemaphoresAsync_v2(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuWaitExternalSemaphoresAsync(<const cydriver.CUexternalSemaphore *>extSemArray, <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS *>paramsArray, numExtSems, stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaArrayGetInfo' in found_functions}}
+
+cdef cudaError_t _cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* extent, unsigned int* flags, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 driverDesc
+    cdef size_t width  = 0
+    cdef size_t height = 0
+    cdef size_t depth  = 0
+
+    # Zero out parameters in case cuArray3DGetDescriptor fails
+    if flags:
+        flags[0] = 0
+
+    if desc:
+        memset(desc, 0, sizeof(desc[0]))
+
+
+    if extent:
+        memset(extent, 0, sizeof(extent[0]))
+
+    err = <cudaError_t>cydriver._cuArray3DGetDescriptor_v2(&driverDesc, <cydriver.CUarray>array)
+    if err != <cudaError_t>cudaSuccess:
+        _setLastError(err)
+        return err
+
+    # Flags are copied directly from the driver API
+    if flags:
+        flags[0] = driverDesc.Flags
+
+    # Convert from driver API types to runtime API types. extent.Depth = 0
+    # indicates a 2D array.
+    if desc:
+        width  = 0
+        height = 0
+        depth  = 0
+
+        err = getChannelFormatDescFromDriverDesc(desc, &depth, &height, &width, &driverDesc)
+        if err != <cudaError_t>cudaSuccess:
+            _setLastError(err)
+            return err
+
+    if extent:
+        extent.width  = driverDesc.Width
+        extent.height = driverDesc.Height
+        extent.depth  = driverDesc.Depth
+
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaMemcpy2DToArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DToArray(dst, hOffset, wOffset, <const char*>src, spitch, width, height, kind, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2DFromArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DFromArray(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DFromArray(<char*>dst, dpitch, src, hOffset, wOffset, width, height, kind, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2DArrayToArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DArrayToArray(dst, hOffsetDst, wOffsetDst, src, hOffsetSrc, wOffsetSrc, width, height, kind)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2DToArrayAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t spitch, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DToArray(dst, hOffset, wOffset, <const char*>src, spitch, width, height, kind, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy2DFromArrayAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t width, size_t height, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy2DFromArray(<char*>dst, dpitch, src, hOffset, wOffset, width, height, kind, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemset3D' in found_functions}}
+
+cdef cudaError_t _cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memset3DPtr(pitchedDevPtr, value, extent, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemset3DAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memset3DPtr(pitchedDevPtr, value, extent, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyToArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyToArray(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyToArray(dst, hOffset, wOffset, <const char*>src, count, kind, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyFromArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyFromArray(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyFromArray(<char*>dst, src, hOffset, wOffset, count, kind, NULL, 0)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyToArrayAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyToArrayAsync(cudaArray_t dst, size_t wOffset, size_t hOffset, const void* src, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyToArray(dst, hOffset, wOffset, <const char*>src, count, kind, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyFromArrayAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size_t wOffset, size_t hOffset, size_t count, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyFromArray(<char*>dst, src, hOffset, wOffset, count, kind, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaPointerGetAttributes' in found_functions}}
+
+cdef cudaError_t _cudaPointerGetAttributes(cudaPointerAttributes* attributes, const void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaPointerAttributes attrib
+    cdef cydriver.CUcontext driverContext = NULL
+    cdef cydriver.CUmemorytype driverMemoryType
+    cdef int isManaged = 0
+    cdef cydriver.CUpointer_attribute[6] query
+    query[0] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT
+    query[1] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE
+    query[2] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER
+    query[3] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER
+    query[4] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED
+    query[5] = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
+
+    memset(&attrib, 0, sizeof(attrib))
+    memset(&driverMemoryType, 0, sizeof(driverMemoryType))
+
+    cdef void** data = [
+        &driverContext,
+        &driverMemoryType,
+        &attrib.devicePointer,
+        &attrib.hostPointer,
+        &isManaged,
+        &attrib.device
+    ]
+
+    if attributes == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    # Get all the attributes we need
+    err = <cudaError_t>cydriver._cuPointerGetAttributes(<unsigned int>(sizeof(query)/sizeof(query[0])), query, data, <cydriver.CUdeviceptr_v2>ptr)
+    if err != cudaSuccess:
+        if attributes != NULL:
+            memset(attributes, 0, sizeof(attributes[0]))
+            attributes[0].device = -1
+        _setLastError(err)
+        return err
+
+    if driverMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST:
+        if isManaged:
+            attrib.type = cudaMemoryTypeManaged
+        else:
+            attrib.type = cudaMemoryTypeHost
+    elif driverMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE:
+        if isManaged:
+            attrib.type = cudaMemoryTypeManaged
+        else:
+            attrib.type = cudaMemoryTypeDevice
+    else:
+         if driverMemoryType == 0:
+            attrib.type = cudaMemoryTypeUnregistered
+         else:
+            if attributes != NULL:
+                memset(attributes, 0, sizeof(attributes[0]))
+                attributes[0].device = -1
+            _setLastError(cudaErrorInvalidValue)
+            return cudaErrorInvalidValue
+
+    # copy to user structure
+    attributes[0] = attrib
+
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaGetDeviceFlags' in found_functions}}
+
+cdef cudaError_t _cudaGetDeviceFlags(unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+
+    if flags == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cydriver.CUcontext driverContext
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&driverContext)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    # Get the flags from the current context
+    if driverContext != NULL:
+        err = <cudaError_t>cydriver._cuCtxGetFlags(flags)
+        if err != cudaSuccess:
+            _setLastError(err)
+        return err
+
+    # Assume first valid device and get its implicit flags
+    cdef cudaPythonDevice* device
+    cdef unsigned int pcFlags
+    cdef int pcActive
+    device = m_global.getDevice(0)
+    err = <cudaError_t>cydriver._cuDevicePrimaryCtxGetState(device[0].driverDevice, &pcFlags, &pcActive)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    flags[0] = pcFlags | cudaDeviceMapHost
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaMemcpy3D' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy3D(const cudaMemcpy3DParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if p == NULL:
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy3D(p, False, 0, 0, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy3DAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy3DAsync(const cudaMemcpy3DParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if p == NULL:
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpy3D(p, False, 0, 0, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemPoolSetAccess' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccessDesc* descList, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    cdef size_t MAX_DEVICES = 32
+    cdef cydriver.CUmemAccessDesc localList[32]
+    cdef cydriver.CUmemAccessDesc *cuDescList
+    cdef size_t i = 0
+
+    if (count > MAX_DEVICES):
+        cuDescList = <cydriver.CUmemAccessDesc*>calloc(sizeof(cydriver.CUmemAccessDesc), count)
+    else:
+        cuDescList = localList
+
+    if cuDescList == NULL:
+        _setLastError(cudaErrorMemoryAllocation)
+        return cudaErrorMemoryAllocation
+
+    while i < count:
+        cuDescList[i].location.type = <cydriver.CUmemLocationType>descList[i].location.type
+        cuDescList[i].location.id = descList[i].location.id
+        cuDescList[i].flags = <cydriver.CUmemAccess_flags>descList[i].flags
+        i += 1
+
+    err = <cudaError_t>cydriver._cuMemPoolSetAccess(memPool, cuDescList, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    if count > MAX_DEVICES:
+        free(cuDescList)
+
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaDeviceReset' in found_functions}}
+
+cdef cudaError_t _cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef int deviceOrdinal = 0
+    cdef cudaError_t err = cudaSuccess
+    if not m_global._lazyInitDriver:
+        return cudaSuccess
+
+    cdef cydriver.CUcontext context
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    cdef cudaPythonDevice* device
+    device = m_global.getDeviceFromPrimaryCtx(context)
+    if device != NULL:
+        err = resetPrimaryContext(device)
+        if err != cudaSuccess:
+            _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaThreadExit' in found_functions}}
+
+cdef cudaError_t _cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cudaDeviceReset()
+
+
+{{endif}}
+{{if 'cudaGetLastError' in found_functions}}
+
+cdef cudaError_t _cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t last_err = m_global._lastError
+    m_global._lastError = cudaSuccess
+    return last_err
+
+
+{{endif}}
+{{if 'cudaPeekAtLastError' in found_functions}}
+
+cdef cudaError_t _cudaPeekAtLastError() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return m_global._lastError
+
+
+{{endif}}
+{{if 'cudaGetDevice' in found_functions}}
+
+cdef cudaError_t _cudaGetDevice(int* deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUdevice driverDevice = 0
+
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+
+    cdef cudaPythonDevice *cudaDevice
+    err = <cudaError_t>cydriver._cuCtxGetDevice(&driverDevice)
+    if err == cudaSuccess:
+        cudaDevice = m_global.getDeviceFromDriver(driverDevice)
+        deviceOrdinal[0] = cudaDevice[0].deviceOrdinal
+    elif err == cudaErrorDeviceUninitialized:
+        # Like C Runtime, default to first device and let context creation happen in another call
+        # By default, device 0 would initialized
+        deviceOrdinal[0] = 0
+        err = cudaSuccess
+    return err
+
+
+{{endif}}
+{{if 'cudaSetDevice' in found_functions}}
+
+cdef cudaError_t _cudaSetDevice(int deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaPythonDevice *device
+
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+
+    device = m_global.getDevice(deviceOrdinal)
+    if device == NULL:
+        _setLastError(err)
+        return cudaErrorInvalidDevice
+
+    if device.primaryContext == NULL:
+        initPrimaryContext(device)
+
+    err = <cudaError_t>cydriver._cuCtxSetCurrent(device.primaryContext)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGetDeviceProperties' in found_functions}}
+
+cdef cudaError_t _cudaGetDeviceProperties(cudaDeviceProp* prop, int deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+
+    device = m_global.getDevice(deviceOrdinal)
+    if device == NULL:
+        _setLastError(err)
+        return cudaErrorInvalidDevice
+
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.kernelExecTimeoutEnabled),  cydriver.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, device[0].driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.computeMode),  cydriver.CU_DEVICE_ATTRIBUTE_COMPUTE_MODE, device[0].driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.clockRate), cydriver.CU_DEVICE_ATTRIBUTE_CLOCK_RATE, device[0].driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryClockRate), cydriver.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, device[0].driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.singleToDoublePrecisionPerfRatio), cydriver.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO, device[0].driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    prop[0] = device[0].deviceProperties
+
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaChooseDevice' in found_functions}}
+
+cdef cudaError_t _cudaChooseDevice(int* device, const cudaDeviceProp* prop) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if device == NULL or prop == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    cdef int best = -1
+    cdef int maxrank = -1
+    cdef int rank = 0
+    cdef char* dontCare_name = [b'\0']
+    cdef int dontCare_major = -1
+    cdef int dontCare_minor = -1
+    cdef size_t dontCare_totalGlobalMem = 0
+    cdef int deviceOrdinal = 0
+    cdef cudaDeviceProp *devProp
+
+    for deviceOrdinal in range(m_global._numDevices):
+        devProp = &m_global._deviceList[deviceOrdinal].deviceProperties
+        rank = 0
+        if (strncmp(prop[0].name, dontCare_name, sizeof(prop[0].name)) != 0):
+            rank += strncmp(prop[0].name, devProp[0].name, sizeof(prop[0].name)) == 0
+        if (prop[0].major != dontCare_major):
+            rank += prop[0].major <= devProp[0].major
+        if (prop[0].major == devProp[0].major and prop[0].minor != dontCare_minor):
+            rank += prop[0].minor <= devProp[0].minor
+        if (prop[0].totalGlobalMem != dontCare_totalGlobalMem):
+            rank += prop[0].totalGlobalMem <= devProp[0].totalGlobalMem
+        if (rank > maxrank):
+            maxrank = rank
+            best = deviceOrdinal
+
+    device[0] = best
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaMemcpyArrayToArray' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyArrayToArray(cudaArray_t dst, size_t wOffsetDst, size_t hOffsetDst, cudaArray_const_t src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = memcpyArrayToArray(dst, hOffsetDst, wOffsetDst, src, hOffsetSrc, wOffsetSrc, count, kind)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGetChannelDesc' in found_functions}}
+
+cdef cudaError_t _cudaGetChannelDesc(cudaChannelFormatDesc* desc, cudaArray_const_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    if desc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = getChannelDesc(array, desc)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaCreateTextureObject' in found_functions}}
+
+cdef cudaError_t _cudaCreateTextureObject(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    if pResDesc == NULL or pTexDesc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cydriver.CUDA_RESOURCE_DESC rd
+    cdef cydriver.CUDA_TEXTURE_DESC td
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC rvd
+    cdef cudaTextureDesc_v2 texDesc
+    memcpy(&texDesc, pTexDesc, sizeof(cudaTextureDesc))
+    texDesc.seamlessCubemap = 0
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if pResViewDesc:
+        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, &texDesc, &rvd, pResViewDesc)
+    else:
+        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, &texDesc, NULL, pResViewDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    if pResViewDesc:
+        err = <cudaError_t>cydriver._cuTexObjectCreate(pTexObject, &rd, &td, &rvd)
+    else:
+        err = <cudaError_t>cydriver._cuTexObjectCreate(pTexObject, &rd, &td, NULL)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaCreateTextureObject_v2' in found_functions}}
+
+cdef cudaError_t _cudaCreateTextureObject_v2(cudaTextureObject_t* pTexObject, const cudaResourceDesc* pResDesc, const cudaTextureDesc_v2* pTexDesc, const cudaResourceViewDesc* pResViewDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    if pResDesc == NULL or pTexDesc == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cydriver.CUDA_RESOURCE_DESC rd
+    cdef cydriver.CUDA_TEXTURE_DESC td
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC rvd
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if pResViewDesc:
+        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, pTexDesc, &rvd, pResViewDesc)
+    else:
+        err = getDriverResDescFromResDesc(&rd, pResDesc, &td, pTexDesc, NULL, pResViewDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    if pResViewDesc:
+        err = <cudaError_t>cydriver._cuTexObjectCreate(pTexObject, &rd, &td, &rvd)
+    else:
+        err = <cudaError_t>cydriver._cuTexObjectCreate(pTexObject, &rd, &td, NULL)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}
+
+cdef cudaError_t _cudaGetTextureObjectTextureDesc(cudaTextureDesc* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    cdef cudaResourceDesc resDesc
+    cdef cydriver.CUDA_RESOURCE_DESC rd
+    cdef cydriver.CUDA_TEXTURE_DESC td
+    cdef cudaTextureDesc_v2 texDesc
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuTexObjectGetResourceDesc(&rd, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuTexObjectGetTextureDesc(&td, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = getResDescFromDriverResDesc(&resDesc, &rd, &texDesc, &td, NULL, NULL)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    memcpy(pTexDesc, &texDesc, sizeof(cudaTextureDesc))
+
+    return cudaSuccess
+
+{{endif}}
+{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}
+
+cdef cudaError_t _cudaGetTextureObjectTextureDesc_v2(cudaTextureDesc_v2* pTexDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    cdef cudaResourceDesc resDesc
+    cdef cydriver.CUDA_RESOURCE_DESC rd
+    cdef cydriver.CUDA_TEXTURE_DESC td
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuTexObjectGetResourceDesc(&rd, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuTexObjectGetTextureDesc(&td, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = getResDescFromDriverResDesc(&resDesc, &rd, pTexDesc, &td, NULL, NULL)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    return cudaSuccess
+
+{{endif}}
+{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}
+
+cdef cudaError_t _cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc* pResViewDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaResourceDesc resDesc
+    cdef cydriver.CUDA_RESOURCE_DESC rd
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC rvd
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err =  <cudaError_t>cydriver.cuTexObjectGetResourceDesc(&rd, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err =  <cudaError_t>cydriver.cuTexObjectGetResourceViewDesc(&rvd, texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = getResDescFromDriverResDesc(&resDesc, &rd, NULL, NULL, pResViewDesc, &rvd)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaGetExportTable' in found_functions}}
+
+cdef cudaError_t _cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGetExportTable(ppExportTable, <const cydriver.CUuuid*>pExportTableId)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpy3DPeer' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy3DPeer(const cudaMemcpy3DPeerParms* p) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if p == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaMemcpy3DParms cp
+    memset(&cp, 0, sizeof(cp))
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cp.srcArray = p[0].srcArray
+    cp.srcPos = p[0].srcPos
+    cp.srcPtr = p[0].srcPtr
+    cp.dstArray = p[0].dstArray
+    cp.dstPos = p[0].dstPos
+    cp.dstPtr = p[0].dstPtr
+    cp.extent = p[0].extent
+    cp.kind = cudaMemcpyKind.cudaMemcpyDeviceToDevice
+
+    err = memcpy3D(&cp, True, p[0].srcDevice, p[0].dstDevice, NULL, False)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemcpy3DPeerAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if p == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaMemcpy3DParms cp
+    memset(&cp, 0, sizeof(cp))
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cp.srcArray = p[0].srcArray
+    cp.srcPos = p[0].srcPos
+    cp.srcPtr = p[0].srcPtr
+    cp.dstArray = p[0].dstArray
+    cp.dstPos = p[0].dstPos
+    cp.dstPtr = p[0].dstPtr
+    cp.extent = p[0].extent
+    cp.kind = cudaMemcpyKind.cudaMemcpyDeviceToDevice
+
+    err = memcpy3D(&cp, True, p[0].srcDevice, p[0].dstDevice, stream, True)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'make_cudaPitchedPtr' in found_functions}}
+
+cdef cudaPitchedPtr _make_cudaPitchedPtr(void* d, size_t p, size_t xsz, size_t ysz) noexcept nogil:
+    cdef cudaPitchedPtr s
+    s.ptr   = d
+    s.pitch = p
+    s.xsize = xsz
+    s.ysize = ysz
+    return s
+
+
+{{endif}}
+{{if 'make_cudaPos' in found_functions}}
+
+cdef cudaPos _make_cudaPos(size_t x, size_t y, size_t z) noexcept nogil:
+    cdef cudaPos p
+    p.x = x
+    p.y = y
+    p.z = z
+    return p
+
+
+{{endif}}
+{{if 'make_cudaExtent' in found_functions}}
+
+cdef cudaExtent _make_cudaExtent(size_t w, size_t h, size_t d) noexcept nogil:
+    cdef cudaExtent e
+    e.width  = w
+    e.height = h
+    e.depth  = d
+    return e
+
+
+{{endif}}
+{{if 'cudaSetDoubleForDevice' in found_functions}}
+
+cdef cudaError_t _cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaSetDoubleForHost' in found_functions}}
+
+cdef cudaError_t _cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaSetDeviceFlags' in found_functions}}
+
+cdef cudaError_t _cudaSetDeviceFlags(unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    flags &= ~cudaDeviceMapHost
+    if flags & ~cudaDeviceMask:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    cdef unsigned int scheduleFlags = flags & cudaDeviceScheduleMask
+    if scheduleFlags and (scheduleFlags != cudaDeviceScheduleSpin and
+                          scheduleFlags != cudaDeviceScheduleYield and
+                          scheduleFlags != cudaDeviceScheduleBlockingSync):
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+
+    cdef cydriver.CUcontext context
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    cdef cudaPythonDevice* device
+    device = m_global.getDeviceFromPrimaryCtx(context)
+    if device == NULL:
+        # We don't know if context provided is primary or not
+        # cudaSetDevice may need to be called before retrying call
+        return cudaErrorIncompatibleDriverContext
+
+    err = <cudaError_t>cydriver._cuDevicePrimaryCtxSetFlags_v2(device[0].driverDevice, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphAddMemAllocNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddMemAllocNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaMemAllocNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    if nodeParams == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+    
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddMemAllocNode(pGraphNode, graph, pDependencies, numDependencies, <cydriver.CUDA_MEM_ALLOC_NODE_PARAMS *>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAllocNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    if params_out == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemAllocNodeGetParams(node, <cydriver.CUDA_MEM_ALLOC_NODE_PARAMS *>params_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    if dptr_out == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemFreeNodeGetParams(node, <cydriver.CUdeviceptr *>dptr_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemAdvise' in found_functions}}
+
+cdef cudaError_t _cudaMemAdvise(const void* devPtr, size_t count, cudaMemoryAdvise advice, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuMemAdvise(<cydriver.CUdeviceptr>devPtr, count, <cydriver.CUmem_advise>advice, <cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemRangeGetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaMemRangeGetAttribute(void* data, size_t dataSize, cudaMemRangeAttribute attribute, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuMemRangeGetAttribute(data, dataSize, <cydriver.CUmem_range_attribute>attribute, <cydriver.CUdeviceptr>devPtr, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMemRangeGetAttributes' in found_functions}}
+
+cdef cudaError_t _cudaMemRangeGetAttributes(void** data, size_t* dataSizes, cudaMemRangeAttribute* attributes, size_t numAttributes, const void* devPtr, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuMemRangeGetAttributes(data, dataSizes, <cydriver.CUmem_range_attribute*>attributes, numAttributes, <cydriver.CUdeviceptr>devPtr, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaGetDeviceCount' in found_functions}}
+
+cdef cudaError_t _cudaGetDeviceCount(int* count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    count[0] = m_global._numDevices
+    return cudaSuccess
+
+
+{{endif}}
+{{if 'cudaDeviceGetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuDeviceGetAttribute(value, <cydriver.CUdevice_attribute>attr, <cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSetSharedMemConfig(<cydriver.CUsharedconfig>config)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceGetByPCIBusId' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetByPCIBusId(int* device, const char* pciBusId) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuDeviceGetByPCIBusId(<cydriver.CUdevice*>device, pciBusId)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceGetPCIBusId' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuDeviceGetPCIBusId(pciBusId, length, <cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceGetP2PAttribute' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetP2PAttribute(int* value, cudaDeviceP2PAttr attr, int srcDevice, int dstDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuDeviceGetP2PAttribute(value, <cydriver.CUdevice_P2PAttribute>attr, <cydriver.CUdevice>srcDevice, <cydriver.CUdevice>dstDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaArrayGetSparseProperties' in found_functions}}
+
+cdef cudaError_t _cudaArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_ARRAY_SPARSE_PROPERTIES _driver_sparseProperties
+    if not sparseProperties:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaError.cudaErrorInvalidValue
+    memset(sparseProperties, 0, sizeof(cudaArraySparseProperties))
+
+    err = <cudaError_t>cydriver._cuArrayGetSparseProperties(&_driver_sparseProperties, <cydriver.CUarray>array)
+    if err == cudaSuccess:
+        sparseProperties[0].miptailFirstLevel = _driver_sparseProperties.miptailFirstLevel
+        sparseProperties[0].miptailSize       = _driver_sparseProperties.miptailSize
+        sparseProperties[0].flags             = _driver_sparseProperties.flags
+        sparseProperties[0].tileExtent.width  = _driver_sparseProperties.tileExtent.width
+        sparseProperties[0].tileExtent.height = _driver_sparseProperties.tileExtent.height
+        sparseProperties[0].tileExtent.depth  = _driver_sparseProperties.tileExtent.depth
+
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaMipmappedArrayGetSparseProperties' in found_functions}}
+
+cdef cudaError_t _cudaMipmappedArrayGetSparseProperties(cudaArraySparseProperties* sparseProperties, cudaMipmappedArray_t mipmap) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_ARRAY_SPARSE_PROPERTIES _driver_sparseProperties
+    if not sparseProperties:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaError.cudaErrorInvalidValue
+    memset(sparseProperties, 0, sizeof(cudaArraySparseProperties))
+
+    err = <cudaError_t>cydriver._cuMipmappedArrayGetSparseProperties(&_driver_sparseProperties, <cydriver.CUmipmappedArray>mipmap)
+    if err == cudaSuccess:
+        sparseProperties[0].miptailFirstLevel = _driver_sparseProperties.miptailFirstLevel
+        sparseProperties[0].miptailSize       = _driver_sparseProperties.miptailSize
+        sparseProperties[0].flags             = _driver_sparseProperties.flags
+        sparseProperties[0].tileExtent.width  = _driver_sparseProperties.tileExtent.width
+        sparseProperties[0].tileExtent.height = _driver_sparseProperties.tileExtent.height
+        sparseProperties[0].tileExtent.depth  = _driver_sparseProperties.tileExtent.depth
+
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceCanAccessPeer' in found_functions}}
+
+cdef cudaError_t _cudaDeviceCanAccessPeer(int* canAccessPeer, int device, int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitDriver()
+    if err != cudaSuccess:
+        return err
+    cdef cudaPythonDevice *driverDevice
+    cdef cudaPythonDevice *driverPeerDevice
+    driverDevice = m_global.getDevice(device)
+    driverPeerDevice = m_global.getDevice(peerDevice)
+    if driverDevice == NULL or driverPeerDevice == NULL:
+        return cudaErrorInvalidDevice
+
+    err = <cudaError_t>cydriver._cuDeviceCanAccessPeer(canAccessPeer, driverDevice.driverDevice, driverPeerDevice.driverDevice)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    if device == peerDevice:
+        canAccessPeer[0] = 0
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyPeer' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyPeer(void* dst, int dstDevice, const void* src, int srcDevice, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaPythonDevice *device
+    cdef cudaPythonDevice *peerDevice
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if count > 0:
+        peerDevice = m_global.getDevice(dstDevice)
+        device = m_global.getDevice(srcDevice)
+        if device == NULL or peerDevice == NULL:
+            _setLastError(err)
+            return cudaErrorInvalidDevice
+        err = initPrimaryContext(peerDevice)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+        err = initPrimaryContext(device)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+        err = <cudaError_t>cydriver._cuMemcpyPeer(<cydriver.CUdeviceptr>dst, peerDevice[0].primaryContext, <cydriver.CUdeviceptr>src, device[0].primaryContext, count)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+    return err
+
+
+{{endif}}
+{{if 'cudaMemcpyPeerAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemcpyPeerAsync(void* dst, int dstDevice, const void* src, int srcDevice, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cudaPythonDevice *device
+    cdef cudaPythonDevice *peerDevice
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if count > 0:
+        peerDevice = m_global.getDevice(dstDevice)
+        device = m_global.getDevice(srcDevice)
+        if device == NULL or peerDevice == NULL:
+            _setLastError(err)
+            return cudaErrorInvalidDevice
+        err = initPrimaryContext(peerDevice)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+        err = initPrimaryContext(device)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+        err = <cudaError_t>cydriver._cuMemcpyPeerAsync(<cydriver.CUdeviceptr>dst, peerDevice[0].primaryContext, <cydriver.CUdeviceptr>src, device[0].primaryContext, count, <cydriver.CUstream>stream)
+        if err != cudaSuccess:
+            _setLastError(err)
+            return err
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceEnablePeerAccess' in found_functions}}
+
+cdef cudaError_t _cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUcontext context
+    cdef cudaPythonDevice *dev
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    dev = m_global.getDeviceFromPrimaryCtx(context)
+    if dev == NULL:
+        # We don't know if context provided is primary or not
+        # cudaSetDevice may need to be called before retrying call
+        _setLastError(cudaErrorIncompatibleDriverContext)
+        return cudaErrorIncompatibleDriverContext
+    dev = m_global.getDevice(peerDevice)
+    if dev == NULL:
+        return cudaErrorInvalidDevice
+    err = initPrimaryContext(dev)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuCtxEnablePeerAccess(dev.primaryContext, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+
+{{endif}}
+{{if 'cudaDeviceDisablePeerAccess' in found_functions}}
+
+cdef cudaError_t _cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUcontext context
+    cdef cudaPythonDevice *dev
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetCurrent(&context)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    dev = m_global.getDeviceFromPrimaryCtx(context)
+    if dev == NULL:
+        # We don't know if context provided is primary or not
+        # cudaSetDevice may need to be called before retrying call
+        _setLastError(cudaErrorIncompatibleDriverContext)
+        return cudaErrorIncompatibleDriverContext
+    dev = m_global.getDevice(peerDevice)
+    if dev == NULL:
+        return cudaErrorInvalidDevice
+    err = initPrimaryContext(dev)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuCtxDisablePeerAccess(dev.primaryContext)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaExternalMemoryGetMappedMipmappedArray' in found_functions}}
+
+cdef cudaError_t _cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t* mipmap, cudaExternalMemory_t extMem, const cudaExternalMemoryMipmappedArrayDesc* mipmapDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC _driver_mipmapDesc
+    memset(&_driver_mipmapDesc, 0, sizeof(_driver_mipmapDesc))
+    _driver_mipmapDesc.offset = mipmapDesc[0].offset
+    _driver_mipmapDesc.arrayDesc.Width = mipmapDesc[0].extent.width
+    _driver_mipmapDesc.arrayDesc.Height = mipmapDesc[0].extent.height
+    _driver_mipmapDesc.arrayDesc.Depth = mipmapDesc[0].extent.depth
+    err_rt = getDescInfo(&mipmapDesc[0].formatDesc, <int *>&_driver_mipmapDesc.arrayDesc.NumChannels, &_driver_mipmapDesc.arrayDesc.Format)
+    if err_rt != cudaError.cudaSuccess:
+        _setLastError(err_rt)
+        return err_rt
+    _driver_mipmapDesc.arrayDesc.Flags = mipmapDesc[0].flags
+    _driver_mipmapDesc.numLevels = mipmapDesc[0].numLevels
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuExternalMemoryGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>mipmap, <cydriver.CUexternalMemory>extMem, &_driver_mipmapDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}
+
+cdef cudaError_t _cudaGetSurfaceObjectResourceDesc(cudaResourceDesc* pResDesc, cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_RESOURCE_DESC _driver_pResDesc
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuSurfObjectGetResourceDesc(&_driver_pResDesc, <cydriver.CUsurfObject>surfObject)
+    memset(pResDesc, 0, sizeof(cudaResourceDesc))
+    if _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_ARRAY:
+        pResDesc[0].resType         = cudaResourceType.cudaResourceTypeArray
+        pResDesc[0].res.array.array = <cudaArray_t>_driver_pResDesc.res.array.hArray
+    elif _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY:
+        pResDesc[0].resType = cudaResourceType.cudaResourceTypeMipmappedArray
+        pResDesc[0].res.mipmap.mipmap = <cudaMipmappedArray_t>_driver_pResDesc.res.mipmap.hMipmappedArray
+    elif _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_LINEAR:
+        pResDesc[0].resType                = cudaResourceType.cudaResourceTypeLinear
+        pResDesc[0].res.linear.devPtr      = <void *>_driver_pResDesc.res.linear.devPtr
+        pResDesc[0].res.linear.sizeInBytes = _driver_pResDesc.res.linear.sizeInBytes
+    elif _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_PITCH2D:
+        pResDesc[0].resType                  = cudaResourceType.cudaResourceTypePitch2D
+        pResDesc[0].res.pitch2D.devPtr       = <void *>_driver_pResDesc.res.pitch2D.devPtr
+        pResDesc[0].res.pitch2D.pitchInBytes = _driver_pResDesc.res.pitch2D.pitchInBytes
+        pResDesc[0].res.pitch2D.width        = _driver_pResDesc.res.pitch2D.width
+        pResDesc[0].res.pitch2D.height       = _driver_pResDesc.res.pitch2D.height
+    if _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_LINEAR or _driver_pResDesc.resType == cydriver.CU_RESOURCE_TYPE_PITCH2D:
+        channel_size = 0
+        if _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_UNSIGNED_INT8:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
+            channel_size = 8
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_UNSIGNED_INT16:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
+            channel_size = 16
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_UNSIGNED_INT32:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
+            channel_size = 32
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_SIGNED_INT8:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
+            channel_size = 8
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_SIGNED_INT16:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
+            channel_size = 16
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_SIGNED_INT32:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindSigned
+            channel_size = 32
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_HALF:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindFloat
+            channel_size = 16
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_FLOAT:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindFloat
+            channel_size = 32
+        elif _driver_pResDesc.res.linear.format == cydriver.CU_AD_FORMAT_NV12:
+            pResDesc[0].res.linear.desc.f = cudaChannelFormatKind.cudaChannelFormatKindNV12
+            channel_size = 8
+        else:
+            _setLastError(cudaErrorInvalidChannelDescriptor)
+            return cudaError.cudaErrorInvalidChannelDescriptor
+        pResDesc[0].res.linear.desc.x = 0
+        pResDesc[0].res.linear.desc.y = 0
+        pResDesc[0].res.linear.desc.z = 0
+        pResDesc[0].res.linear.desc.w = 0
+        if _driver_pResDesc.res.linear.numChannels >= 4:
+            pResDesc[0].res.linear.desc.w = channel_size
+        if _driver_pResDesc.res.linear.numChannels >= 3:
+            pResDesc[0].res.linear.desc.z = channel_size
+        if _driver_pResDesc.res.linear.numChannels >= 2:
+            pResDesc[0].res.linear.desc.y = channel_size
+        if _driver_pResDesc.res.linear.numChannels >= 1:
+            pResDesc[0].res.linear.desc.x = channel_size
+        if _driver_pResDesc.res.linear.numChannels < 1 or _driver_pResDesc.res.linear.numChannels >= 5:
+            _setLastError(cudaErrorInvalidChannelDescriptor)
+            return cudaError.cudaErrorInvalidChannelDescriptor
+
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphKernelNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphKernelNodeGetParams(<cydriver.CUgraphNode>node, &_driver_pNodeParams)
+    pNodeParams[0].func = <void*>_driver_pNodeParams.func
+    pNodeParams[0].gridDim.x = _driver_pNodeParams.gridDimX
+    pNodeParams[0].gridDim.y = _driver_pNodeParams.gridDimY
+    pNodeParams[0].gridDim.z = _driver_pNodeParams.gridDimZ
+    pNodeParams[0].blockDim.x = _driver_pNodeParams.blockDimX
+    pNodeParams[0].blockDim.y = _driver_pNodeParams.blockDimY
+    pNodeParams[0].blockDim.z = _driver_pNodeParams.blockDimZ
+    pNodeParams[0].sharedMemBytes = _driver_pNodeParams.sharedMemBytes
+    pNodeParams[0].kernelParams = _driver_pNodeParams.kernelParams
+    pNodeParams[0].extra = _driver_pNodeParams.extra
+
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaExternalMemoryGetMappedBuffer' in found_functions}}
+
+cdef cudaError_t _cudaExternalMemoryGetMappedBuffer(void** devPtr, cudaExternalMemory_t extMem, const cudaExternalMemoryBufferDesc* bufferDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC _driver_bufferDesc
+    memset(&_driver_bufferDesc, 0, sizeof(_driver_bufferDesc))
+    _driver_bufferDesc.offset = bufferDesc[0].offset
+    _driver_bufferDesc.size = bufferDesc[0].size
+    _driver_bufferDesc.flags = bufferDesc[0].flags
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuExternalMemoryGetMappedBuffer(<cydriver.CUdeviceptr*>devPtr, <cydriver.CUexternalMemory>extMem, &_driver_bufferDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaImportExternalMemory' in found_functions}}
+
+cdef cudaError_t _cudaImportExternalMemory(cudaExternalMemory_t* extMem_out, const cudaExternalMemoryHandleDesc* memHandleDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC _driver_memHandleDesc
+    memset(&_driver_memHandleDesc, 0, sizeof(_driver_memHandleDesc))
+
+    if memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD
+        _driver_memHandleDesc.handle.fd = memHandleDesc[0].handle.fd
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
+        _driver_memHandleDesc.handle.win32.handle = memHandleDesc[0].handle.win32.handle
+        _driver_memHandleDesc.handle.win32.name = memHandleDesc[0].handle.win32.name
+    elif memHandleDesc[0].type == cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf:
+        _driver_memHandleDesc.type = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF
+        _driver_memHandleDesc.handle.nvSciBufObject = memHandleDesc[0].handle.nvSciBufObject
+    _driver_memHandleDesc.size = memHandleDesc[0].size
+    _driver_memHandleDesc.flags = memHandleDesc[0].flags
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuImportExternalMemory(<cydriver.CUexternalMemory*>extMem_out, &_driver_memHandleDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaCreateSurfaceObject' in found_functions}}
+
+cdef cudaError_t _cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const cudaResourceDesc* pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cdef cydriver.CUDA_RESOURCE_DESC _driver_pResDesc
+    memset(&_driver_pResDesc, 0, sizeof(_driver_pResDesc))
+    err = toDriverCudaResourceDesc(&_driver_pResDesc, pResDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuSurfObjectCreate(<cydriver.CUsurfObject*>pSurfObject, &_driver_pResDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}
+
+cdef cudaError_t _cudaGetTextureObjectResourceDesc(cudaResourceDesc* pResDesc, cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cdef cydriver.CUDA_RESOURCE_DESC _driver_pResDesc
+    memset(&_driver_pResDesc, 0, sizeof(_driver_pResDesc))
+    err = toDriverCudaResourceDesc(&_driver_pResDesc, pResDesc)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    err = <cudaError_t>cydriver._cuTexObjectGetResourceDesc(&_driver_pResDesc, <cydriver.CUtexObject>texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+
+cdef cudaError_t _cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuProfilerInitialize(configFile, outputFile, <cydriver.CUoutput_mode>outputMode)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+cdef cudaError_t _cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cdef cydriver.CUeglFrame cueglFrame
+    err = getDriverEglFrame(&cueglFrame, eglframe)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamProducerPresentFrame(<cydriver.CUeglStreamConnection*>conn, cueglFrame, pStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+cdef cudaError_t _cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    if eglframe == NULL:
+        err = cudaErrorInvalidResourceHandle
+        _setLastError(err)
+        return err
+    cdef cydriver.CUeglFrame cueglFrame
+    err = <cudaError_t>cydriver._cuEGLStreamProducerReturnFrame(<cydriver.CUeglStreamConnection*>conn, &cueglFrame, pStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = getRuntimeEglFrame(eglframe, cueglFrame)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    return err
+
+cdef cudaError_t _cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    cdef cydriver.CUeglFrame cueglFrame
+    memset(&cueglFrame, 0, sizeof(cueglFrame))
+    err = <cudaError_t>cydriver._cuGraphicsResourceGetMappedEglFrame(&cueglFrame, <cydriver.CUgraphicsResource>resource, index, mipLevel)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    err = getRuntimeEglFrame(eglFrame, cueglFrame)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+    return err
+
+cdef cudaError_t _cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return cudaErrorNotSupported
+
+{{if 'cudaArrayGetMemoryRequirements' in found_functions}}
+
+cdef cudaError_t _cudaArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaArray_t array, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS driverMemoryRequirements
+    if memoryRequirements == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    memset(memoryRequirements, 0, sizeof(memoryRequirements[0]))
+    err = <cudaError_t>cydriver._cuArrayGetMemoryRequirements(&driverMemoryRequirements, <cydriver.CUarray>array, device)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    memoryRequirements[0].size = driverMemoryRequirements.size
+    memoryRequirements[0].alignment = driverMemoryRequirements.alignment
+    return cudaSuccess
+
+{{endif}}
+{{if 'cudaMipmappedArrayGetMemoryRequirements' in found_functions}}
+
+cdef cudaError_t _cudaMipmappedArrayGetMemoryRequirements(cudaArrayMemoryRequirements* memoryRequirements, cudaMipmappedArray_t mipmap, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS driverMemoryRequirements
+    if memoryRequirements == NULL:
+        _setLastError(cudaErrorInvalidValue)
+        return cudaErrorInvalidValue
+
+    memset(memoryRequirements, 0, sizeof(memoryRequirements[0]))
+    err = <cudaError_t>cydriver._cuMipmappedArrayGetMemoryRequirements(&driverMemoryRequirements, <cydriver.CUmipmappedArray>mipmap, device)
+    if err != cudaSuccess:
+        _setLastError(err)
+        return err
+
+    memoryRequirements[0].size = driverMemoryRequirements.size
+    memoryRequirements[0].alignment = driverMemoryRequirements.alignment
+    return cudaSuccess
+
+{{endif}}
+{{if 'cudaStreamGetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaStreamGetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, cudaStreamAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamGetAttribute(<cydriver.CUstream>hStream, <cydriver.CUstreamAttrID>attr, <cydriver.CUstreamAttrValue*>value_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamSetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID attr, const cudaStreamAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamSetAttribute(<cydriver.CUstream>hStream, <cydriver.CUstreamAttrID>attr, <cydriver.CUstreamAttrValue*>value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaGraphKernelNodeGetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, cudaKernelNodeAttrValue* value_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphKernelNodeGetAttribute(<cydriver.CUgraphNode>hNode, <cydriver.CUkernelNodeAttrID>attr, <cydriver.CUkernelNodeAttrValue*>value_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaGraphKernelNodeSetAttribute(cudaGraphNode_t hNode, cudaKernelNodeAttrID attr, const cudaKernelNodeAttrValue* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphKernelNodeSetAttribute(<cydriver.CUgraphNode>hNode, <cydriver.CUkernelNodeAttrID>attr, <cydriver.CUkernelNodeAttrValue*>value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _getLocalRuntimeVersion(int* runtimeVersion) except ?cudaErrorCallRequiresNewerDriver nogil:
+    {{if 'Windows' == platform.system()}}
+    with gil:
+        raise NotImplementedError('"getLocalRuntimeVersion" is unsupported on Windows')
+    {{else}}
+    # Load
+    handle = dlfcn.dlopen('libcudart.so.11.0', dlfcn.RTLD_NOW)
+    if handle == NULL:
+        with gil:
+            raise RuntimeError(f'Failed to dlopen libcudart.so.11.0')
+
+    __cudaRuntimeGetVersion = dlfcn.dlsym(handle, 'cudaRuntimeGetVersion')
+
+    if __cudaRuntimeGetVersion == NULL:
+        with gil:
+            raise RuntimeError(f'Function "cudaRuntimeGetVersion" not found in libcudart.so.11.0')
+
+    # Call
+    cdef cudaError_t err = cudaSuccess
+    err = (<cudaError_t (*)(int*) except ?cudaErrorCallRequiresNewerDriver nogil> __cudaRuntimeGetVersion)(runtimeVersion)
+
+    # Unload
+    dlfcn.dlclose(handle)
+
+    # Return
+    return err
+    {{endif}}
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuVDPAUGetDevice(<cydriver.CUdevice*>device, vdpDevice, vdpGetProcAddress)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsVDPAURegisterVideoSurface(<cydriver.CUgraphicsResource*>resource, vdpSurface, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsVDPAURegisterOutputSurface(<cydriver.CUgraphicsResource*>resource, vdpSurface, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGLGetDevices_v2(pCudaDeviceCount, <cydriver.CUdevice*>pCudaDevices, cudaDeviceCount, <cydriver.CUGLDeviceList>deviceList)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsGLRegisterImage(<cydriver.CUgraphicsResource*>resource, image, target, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsGLRegisterBuffer(<cydriver.CUgraphicsResource*>resource, buffer, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceSynchronize' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSynchronize()
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceSetLimit' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSetLimit(<cydriver.CUlimit>limit, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetLimit' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetLimit(pValue, <cydriver.CUlimit>limit)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetCacheConfig' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetCacheConfig(<cydriver.CUfunc_cache*>pCacheConfig)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetStreamPriorityRange(leastPriority, greatestPriority)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceSetCacheConfig' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSetCacheConfig(<cydriver.CUfunc_cache>cacheConfig)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetSharedMemConfig' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetSharedMemConfig(<cydriver.CUsharedconfig*>pConfig)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaIpcGetEventHandle' in found_functions}}
+
+cdef cudaError_t _cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuIpcGetEventHandle(<cydriver.CUipcEventHandle*>handle, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaIpcOpenEventHandle' in found_functions}}
+
+cdef cudaError_t _cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUipcEventHandle _driver_handle
+    memcpy(&_driver_handle, &handle, sizeof(_driver_handle))
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuIpcOpenEventHandle(<cydriver.CUevent*>event, _driver_handle)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaIpcGetMemHandle' in found_functions}}
+
+cdef cudaError_t _cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuIpcGetMemHandle(<cydriver.CUipcMemHandle*>handle, <cydriver.CUdeviceptr>devPtr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaIpcOpenMemHandle' in found_functions}}
+
+cdef cudaError_t _cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUipcMemHandle _driver_handle
+    memcpy(&_driver_handle, &handle, sizeof(_driver_handle))
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuIpcOpenMemHandle_v2(<cydriver.CUdeviceptr*>devPtr, _driver_handle, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaIpcCloseMemHandle' in found_functions}}
+
+cdef cudaError_t _cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuIpcCloseMemHandle(<cydriver.CUdeviceptr>devPtr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}
+
+cdef cudaError_t _cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuFlushGPUDirectRDMAWrites(<cydriver.CUflushGPUDirectRDMAWritesTarget>target, <cydriver.CUflushGPUDirectRDMAWritesScope>scope)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaThreadSynchronize' in found_functions}}
+
+cdef cudaError_t _cudaThreadSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSynchronize()
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaThreadSetLimit' in found_functions}}
+
+cdef cudaError_t _cudaThreadSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxSetLimit(<cydriver.CUlimit>limit, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaThreadGetLimit' in found_functions}}
+
+cdef cudaError_t _cudaThreadGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxGetLimit(pValue, <cydriver.CUlimit>limit)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetDefaultMemPool' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGetDefaultMemPool(<cydriver.CUmemoryPool*>memPool, <cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceSetMemPool' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceSetMemPool(<cydriver.CUdevice>device, <cydriver.CUmemoryPool>memPool)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetMemPool' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGetMemPool(<cydriver.CUmemoryPool*>memPool, <cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, <cydriver.CUdevice>device, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamCreateWithFlags' in found_functions}}
+
+cdef cudaError_t _cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamCreate(<cydriver.CUstream*>pStream, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamCreateWithPriority' in found_functions}}
+
+cdef cudaError_t _cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamCreateWithPriority(<cydriver.CUstream*>pStream, flags, priority)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamGetPriority' in found_functions}}
+
+cdef cudaError_t _cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamGetPriority(<cydriver.CUstream>hStream, priority)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamGetFlags' in found_functions}}
+
+cdef cudaError_t _cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamGetFlags(<cydriver.CUstream>hStream, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaCtxResetPersistingL2Cache' in found_functions}}
+
+cdef cudaError_t _cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuCtxResetPersistingL2Cache()
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamCopyAttributes' in found_functions}}
+
+cdef cudaError_t _cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamCopyAttributes(<cydriver.CUstream>dst, <cydriver.CUstream>src)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamDestroy' in found_functions}}
+
+cdef cudaError_t _cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamDestroy_v2(<cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamWaitEvent' in found_functions}}
+
+cdef cudaError_t _cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamWaitEvent(<cydriver.CUstream>stream, <cydriver.CUevent>event, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamSynchronize' in found_functions}}
+
+cdef cudaError_t _cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamSynchronize(<cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamQuery' in found_functions}}
+
+cdef cudaError_t _cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamQuery(<cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamAttachMemAsync' in found_functions}}
+
+cdef cudaError_t _cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamAttachMemAsync(<cydriver.CUstream>stream, <cydriver.CUdeviceptr>devPtr, length, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamBeginCapture' in found_functions}}
+
+cdef cudaError_t _cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamBeginCapture_v2(<cydriver.CUstream>stream, <cydriver.CUstreamCaptureMode>mode)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}}
+
+cdef cudaError_t _cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuThreadExchangeStreamCaptureMode(<cydriver.CUstreamCaptureMode*>mode)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamEndCapture' in found_functions}}
+
+cdef cudaError_t _cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamEndCapture(<cydriver.CUstream>stream, <cydriver.CUgraph*>pGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamIsCapturing' in found_functions}}
+
+cdef cudaError_t _cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamIsCapturing(<cydriver.CUstream>stream, <cydriver.CUstreamCaptureStatus*>pCaptureStatus)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}
+
+cdef cudaError_t _cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuStreamUpdateCaptureDependencies(<cydriver.CUstream>stream, <cydriver.CUgraphNode*>dependencies, numDependencies, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventCreateWithFlags' in found_functions}}
+
+cdef cudaError_t _cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventCreate(<cydriver.CUevent*>event, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventRecord' in found_functions}}
+
+cdef cudaError_t _cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventRecord(<cydriver.CUevent>event, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventRecordWithFlags' in found_functions}}
+
+cdef cudaError_t _cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventRecordWithFlags(<cydriver.CUevent>event, <cydriver.CUstream>stream, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventSynchronize' in found_functions}}
+
+cdef cudaError_t _cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventSynchronize(<cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventDestroy' in found_functions}}
+
+cdef cudaError_t _cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventDestroy_v2(<cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaEventElapsedTime' in found_functions}}
+
+cdef cudaError_t _cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventElapsedTime(ms, <cydriver.CUevent>start, <cydriver.CUevent>end)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDestroyExternalMemory' in found_functions}}
+
+cdef cudaError_t _cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDestroyExternalMemory(<cydriver.CUexternalMemory>extMem)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDestroyExternalSemaphore' in found_functions}}
+
+cdef cudaError_t _cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDestroyExternalSemaphore(<cydriver.CUexternalSemaphore>extSem)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFuncSetCacheConfig' in found_functions}}
+
+cdef cudaError_t _cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuFuncSetCacheConfig(<cydriver.CUfunction>func, <cydriver.CUfunc_cache>cacheConfig)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFuncSetSharedMemConfig' in found_functions}}
+
+cdef cudaError_t _cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuFuncSetSharedMemConfig(<cydriver.CUfunction>func, <cydriver.CUsharedconfig>config)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFuncSetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuFuncSetAttribute(<cydriver.CUfunction>func, <cydriver.CUfunction_attribute>attr, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaLaunchHostFunc' in found_functions}}
+
+cdef cudaError_t _cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuLaunchHostFunc(<cydriver.CUstream>stream, <cydriver.CUhostFn>fn, userData)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}
+
+cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, <cydriver.CUfunction>func, blockSize, dynamicSMemSize)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}}
+
+cdef cudaError_t _cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, <cydriver.CUfunction>func, numBlocks, blockSize)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}
+
+cdef cudaError_t _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, <cydriver.CUfunction>func, blockSize, dynamicSMemSize, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMallocManaged' in found_functions}}
+
+cdef cudaError_t _cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemAllocManaged(<cydriver.CUdeviceptr*>devPtr, size, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMalloc' in found_functions}}
+
+cdef cudaError_t _cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemAlloc_v2(<cydriver.CUdeviceptr*>devPtr, size)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFree' in found_functions}}
+
+cdef cudaError_t _cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemFree_v2(<cydriver.CUdeviceptr>devPtr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFreeHost' in found_functions}}
+
+cdef cudaError_t _cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemFreeHost(ptr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFreeArray' in found_functions}}
+
+cdef cudaError_t _cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuArrayDestroy(<cydriver.CUarray>array)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFreeMipmappedArray' in found_functions}}
+
+cdef cudaError_t _cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMipmappedArrayDestroy(<cydriver.CUmipmappedArray>mipmappedArray)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaHostAlloc' in found_functions}}
+
+cdef cudaError_t _cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemHostAlloc(pHost, size, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaHostRegister' in found_functions}}
+
+cdef cudaError_t _cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemHostRegister_v2(ptr, size, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaHostUnregister' in found_functions}}
+
+cdef cudaError_t _cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemHostUnregister(ptr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaHostGetDevicePointer' in found_functions}}
+
+cdef cudaError_t _cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemHostGetDevicePointer_v2(<cydriver.CUdeviceptr*>pDevice, pHost, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaHostGetFlags' in found_functions}}
+
+cdef cudaError_t _cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemHostGetFlags(pFlags, pHost)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGetMipmappedArrayLevel' in found_functions}}
+
+cdef cudaError_t _cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMipmappedArrayGetLevel(<cydriver.CUarray*>levelArray, <cydriver.CUmipmappedArray>mipmappedArray, level)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemGetInfo' in found_functions}}
+
+cdef cudaError_t _cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemGetInfo_v2(free, total)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaArrayGetPlane' in found_functions}}
+
+cdef cudaError_t _cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuArrayGetPlane(<cydriver.CUarray*>pPlaneArray, <cydriver.CUarray>hArray, planeIdx)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemset' in found_functions}}
+
+cdef cudaError_t _cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemsetD8_v2(<cydriver.CUdeviceptr>devPtr, <unsigned char>value, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemset2D' in found_functions}}
+
+cdef cudaError_t _cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemsetD2D8_v2(<cydriver.CUdeviceptr>devPtr, pitch, <unsigned char>value, width, height)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemsetAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemsetD8Async(<cydriver.CUdeviceptr>devPtr, <unsigned char>value, count, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemset2DAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemsetD2D8Async(<cydriver.CUdeviceptr>devPtr, pitch, <unsigned char>value, width, height, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPrefetchAsync' in found_functions}}
+
+cdef cudaError_t _cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPrefetchAsync(<cydriver.CUdeviceptr>devPtr, count, <cydriver.CUdevice>dstDevice, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMallocAsync' in found_functions}}
+
+cdef cudaError_t _cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemAllocAsync(<cydriver.CUdeviceptr*>devPtr, size, <cydriver.CUstream>hStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaFreeAsync' in found_functions}}
+
+cdef cudaError_t _cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemFreeAsync(<cydriver.CUdeviceptr>devPtr, <cydriver.CUstream>hStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolTrimTo' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolTrimTo(<cydriver.CUmemoryPool>memPool, minBytesToKeep)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolSetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolSetAttribute(<cydriver.CUmemoryPool>memPool, <cydriver.CUmemPool_attribute>attr, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolGetAttribute' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolGetAttribute(<cydriver.CUmemoryPool>memPool, <cydriver.CUmemPool_attribute>attr, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolGetAccess' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolGetAccess(<cydriver.CUmemAccess_flags*>flags, <cydriver.CUmemoryPool>memPool, <cydriver.CUmemLocation*>location)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolCreate' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolCreate(<cydriver.CUmemoryPool*>memPool, <cydriver.CUmemPoolProps*>poolProps)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolDestroy' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolDestroy(<cydriver.CUmemoryPool>memPool)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMallocFromPoolAsync' in found_functions}}
+
+cdef cudaError_t _cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemAllocFromPoolAsync(<cydriver.CUdeviceptr*>ptr, size, <cydriver.CUmemoryPool>memPool, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolExportToShareableHandle' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolExportToShareableHandle(shareableHandle, <cydriver.CUmemoryPool>memPool, <cydriver.CUmemAllocationHandleType>handleType, <unsigned long long>flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolImportFromShareableHandle(<cydriver.CUmemoryPool*>memPool, shareableHandle, <cydriver.CUmemAllocationHandleType>handleType, <unsigned long long>flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolExportPointer' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolExportPointer(<cydriver.CUmemPoolPtrExportData*>exportData, <cydriver.CUdeviceptr>ptr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaMemPoolImportPointer' in found_functions}}
+
+cdef cudaError_t _cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuMemPoolImportPointer(<cydriver.CUdeviceptr*>ptr, <cydriver.CUmemoryPool>memPool, <cydriver.CUmemPoolPtrExportData*>exportData)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsUnregisterResource' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsUnregisterResource(<cydriver.CUgraphicsResource>resource)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsResourceSetMapFlags' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsResourceSetMapFlags_v2(<cydriver.CUgraphicsResource>resource, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsMapResources' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsMapResources(<unsigned int>count, <cydriver.CUgraphicsResource*>resources, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsUnmapResources' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsUnmapResources(<unsigned int>count, <cydriver.CUgraphicsResource*>resources, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsResourceGetMappedPointer_v2(<cydriver.CUdeviceptr*>devPtr, size, <cydriver.CUgraphicsResource>resource)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsSubResourceGetMappedArray(<cydriver.CUarray*>array, <cydriver.CUgraphicsResource>resource, arrayIndex, mipLevel)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}}
+
+cdef cudaError_t _cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsResourceGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>mipmappedArray, <cydriver.CUgraphicsResource>resource)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDestroyTextureObject' in found_functions}}
+
+cdef cudaError_t _cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuTexObjectDestroy(<cydriver.CUtexObject>texObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDestroySurfaceObject' in found_functions}}
+
+cdef cudaError_t _cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuSurfObjectDestroy(<cydriver.CUsurfObject>surfObject)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphCreate' in found_functions}}
+
+cdef cudaError_t _cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphCreate(<cydriver.CUgraph*>pGraph, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddKernelNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
+    _driver_pNodeParams.func = <cydriver.CUfunction>pNodeParams[0].func
+    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
+    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
+    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
+    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
+    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
+    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
+    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
+    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
+    _driver_pNodeParams.extra = pNodeParams[0].extra
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddKernelNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, &_driver_pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphKernelNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
+    _driver_pNodeParams.func = <cydriver.CUfunction>pNodeParams[0].func
+    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
+    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
+    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
+    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
+    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
+    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
+    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
+    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
+    _driver_pNodeParams.extra = pNodeParams[0].extra
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphKernelNodeSetParams(<cydriver.CUgraphNode>node, &_driver_pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}
+
+cdef cudaError_t _cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphKernelNodeCopyAttributes(<cydriver.CUgraphNode>hSrc, <cydriver.CUgraphNode>hDst)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphMemsetNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemsetNodeGetParams(<cydriver.CUgraphNode>node, <cydriver.CUDA_MEMSET_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphMemsetNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphMemsetNodeSetParams(<cydriver.CUgraphNode>node, <cydriver.CUDA_MEMSET_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddHostNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddHostNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUDA_HOST_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphHostNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphHostNodeGetParams(<cydriver.CUgraphNode>node, <cydriver.CUDA_HOST_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphHostNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphHostNodeSetParams(<cydriver.CUgraphNode>node, <cydriver.CUDA_HOST_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddChildGraphNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddChildGraphNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUgraph>childGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}
+
+cdef cudaError_t _cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphChildGraphNodeGetGraph(<cydriver.CUgraphNode>node, <cydriver.CUgraph*>pGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddEmptyNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddEmptyNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddEventRecordNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddEventRecordNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphEventRecordNodeGetEvent(<cydriver.CUgraphNode>node, <cydriver.CUevent*>event_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphEventRecordNodeSetEvent(<cydriver.CUgraphNode>node, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddEventWaitNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddEventWaitNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphEventWaitNodeGetEvent(<cydriver.CUgraphNode>node, <cydriver.CUevent*>event_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphEventWaitNodeSetEvent(<cydriver.CUgraphNode>node, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddExternalSemaphoresSignalNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExternalSemaphoresSignalNodeGetParams(<cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>params_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExternalSemaphoresSignalNodeSetParams(<cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddExternalSemaphoresWaitNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExternalSemaphoresWaitNodeGetParams(<cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>params_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExternalSemaphoresWaitNodeSetParams(<cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddMemFreeNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddMemFreeNode(<cydriver.CUgraphNode*>pGraphNode, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pDependencies, numDependencies, <cydriver.CUdeviceptr>dptr)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGraphMemTrim' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGraphMemTrim(<cydriver.CUdevice>device)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}
+
+cdef cudaError_t _cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceGetGraphMemAttribute(<cydriver.CUdevice>device, <cydriver.CUgraphMem_attribute>attr, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}
+
+cdef cudaError_t _cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuDeviceSetGraphMemAttribute(<cydriver.CUdevice>device, <cydriver.CUgraphMem_attribute>attr, value)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphClone' in found_functions}}
+
+cdef cudaError_t _cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphClone(<cydriver.CUgraph*>pGraphClone, <cydriver.CUgraph>originalGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeFindInClone' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeFindInClone(<cydriver.CUgraphNode*>pNode, <cydriver.CUgraphNode>originalNode, <cydriver.CUgraph>clonedGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeGetType' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeGetType(<cydriver.CUgraphNode>node, <cydriver.CUgraphNodeType*>pType)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphGetNodes' in found_functions}}
+
+cdef cudaError_t _cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphGetNodes(<cydriver.CUgraph>graph, <cydriver.CUgraphNode*>nodes, numNodes)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphGetRootNodes' in found_functions}}
+
+cdef cudaError_t _cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphGetRootNodes(<cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pRootNodes, pNumRootNodes)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphGetEdges' in found_functions}}
+
+cdef cudaError_t _cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphGetEdges(<cydriver.CUgraph>graph, <cydriver.CUgraphNode*>from_, <cydriver.CUgraphNode*>to, numEdges)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeGetDependencies' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeGetDependencies(<cydriver.CUgraphNode>node, <cydriver.CUgraphNode*>pDependencies, pNumDependencies)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeGetDependentNodes' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeGetDependentNodes(<cydriver.CUgraphNode>node, <cydriver.CUgraphNode*>pDependentNodes, pNumDependentNodes)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphAddDependencies' in found_functions}}
+
+cdef cudaError_t _cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphAddDependencies(<cydriver.CUgraph>graph, <cydriver.CUgraphNode*>from_, <cydriver.CUgraphNode*>to, numDependencies)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphRemoveDependencies' in found_functions}}
+
+cdef cudaError_t _cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphRemoveDependencies(<cydriver.CUgraph>graph, <cydriver.CUgraphNode*>from_, <cydriver.CUgraphNode*>to, numDependencies)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphDestroyNode' in found_functions}}
+
+cdef cudaError_t _cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphDestroyNode(<cydriver.CUgraphNode>node)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphInstantiate' in found_functions}}
+
+cdef cudaError_t _cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphInstantiate_v2(<cydriver.CUgraphExec*>pGraphExec, <cydriver.CUgraph>graph, <cydriver.CUgraphNode*>pErrorNode, pLogBuffer, bufferSize)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphInstantiateWithFlags' in found_functions}}
+
+cdef cudaError_t _cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphInstantiateWithFlags(<cydriver.CUgraphExec*>pGraphExec, <cydriver.CUgraph>graph, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
+    _driver_pNodeParams.func = <cydriver.CUfunction>pNodeParams[0].func
+    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
+    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
+    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
+    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
+    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
+    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
+    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
+    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
+    _driver_pNodeParams.extra = pNodeParams[0].extra
+
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecKernelNodeSetParams(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>node, &_driver_pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecHostNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecHostNodeSetParams(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>node, <cydriver.CUDA_HOST_NODE_PARAMS*>pNodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecChildGraphNodeSetParams(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>node, <cydriver.CUgraph>childGraph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecEventRecordNodeSetEvent(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecEventWaitNodeSetEvent(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, <cydriver.CUevent>event)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecExternalSemaphoresSignalNodeSetParams(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecExternalSemaphoresWaitNodeSetParams(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeSetEnabled' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeSetEnabled(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, isEnabled)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphNodeGetEnabled' in found_functions}}
+
+cdef cudaError_t _cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphNodeGetEnabled(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraphNode>hNode, isEnabled)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecUpdate' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t* hErrorNode_out, cudaGraphExecUpdateResult* updateResult_out) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecUpdate(<cydriver.CUgraphExec>hGraphExec, <cydriver.CUgraph>hGraph, <cydriver.CUgraphNode*>hErrorNode_out, <cydriver.CUgraphExecUpdateResult*>updateResult_out)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphUpload' in found_functions}}
+
+cdef cudaError_t _cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphUpload(<cydriver.CUgraphExec>graphExec, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphLaunch' in found_functions}}
+
+cdef cudaError_t _cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphLaunch(<cydriver.CUgraphExec>graphExec, <cydriver.CUstream>stream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphExecDestroy' in found_functions}}
+
+cdef cudaError_t _cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphExecDestroy(<cydriver.CUgraphExec>graphExec)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphDestroy' in found_functions}}
+
+cdef cudaError_t _cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphDestroy(<cydriver.CUgraph>graph)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphDebugDotPrint' in found_functions}}
+
+cdef cudaError_t _cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphDebugDotPrint(<cydriver.CUgraph>graph, path, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaUserObjectCreate' in found_functions}}
+
+cdef cudaError_t _cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuUserObjectCreate(<cydriver.CUuserObject*>object_out, ptr, <cydriver.CUhostFn>destroy, initialRefcount, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaUserObjectRetain' in found_functions}}
+
+cdef cudaError_t _cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuUserObjectRetain(<cydriver.CUuserObject>object, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaUserObjectRelease' in found_functions}}
+
+cdef cudaError_t _cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuUserObjectRelease(<cydriver.CUuserObject>object, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphRetainUserObject' in found_functions}}
+
+cdef cudaError_t _cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphRetainUserObject(<cydriver.CUgraph>graph, <cydriver.CUuserObject>object, count, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if 'cudaGraphReleaseUserObject' in found_functions}}
+
+cdef cudaError_t _cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphReleaseUserObject(<cydriver.CUgraph>graph, <cydriver.CUuserObject>object, count)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuProfilerStart()
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuProfilerStop()
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuGraphicsEGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource, image, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamConsumerConnect(<cydriver.CUeglStreamConnection*>conn, eglStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamConsumerConnectWithFlags(<cydriver.CUeglStreamConnection*>conn, eglStream, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamConsumerDisconnect(<cydriver.CUeglStreamConnection*>conn)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamConsumerAcquireFrame(<cydriver.CUeglStreamConnection*>conn, <cydriver.CUgraphicsResource*>pCudaResource, <cydriver.CUstream*>pStream, timeout)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamConsumerReleaseFrame(<cydriver.CUeglStreamConnection*>conn, <cydriver.CUgraphicsResource>pCudaResource, <cydriver.CUstream*>pStream)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamProducerConnect(<cydriver.CUeglStreamConnection*>conn, eglStream, width, height)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEGLStreamProducerDisconnect(<cydriver.CUeglStreamConnection*>conn)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
+{{if True}}
+
+cdef cudaError_t _cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
+    err = m_global.lazyInitContextState()
+    if err != cudaSuccess:
+        return err
+    err = <cudaError_t>cydriver._cuEventCreateFromEGLSync(<cydriver.CUevent*>phEvent, eglSync, flags)
+    if err != cudaSuccess:
+        _setLastError(err)
+    return err
+
+{{endif}}
diff --git a/cuda/_lib/ccudart/utils.pxd.in b/cuda/cuda/bindings/_lib/cyruntime/utils.pxd.in
similarity index 68%
rename from cuda/_lib/ccudart/utils.pxd.in
rename to cuda/cuda/bindings/_lib/cyruntime/utils.pxd.in
index 2a6d90c4..f01e6225 100644
--- a/cuda/_lib/ccudart/utils.pxd.in
+++ b/cuda/cuda/bindings/_lib/cyruntime/utils.pxd.in
@@ -1,19 +1,19 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-from cuda.ccudart cimport *
+from cuda.bindings.cyruntime cimport *
 from libc.stdlib cimport malloc, free, calloc
 from libc.string cimport memset, memcpy, strncmp
 from libcpp cimport bool
-cimport cuda._cuda.ccuda as ccuda
+cimport cuda.bindings._bindings.cydriver as cydriver
 
 cdef struct cudaPythonDevice:
-    ccuda.CUdevice driverDevice
-    ccuda.CUcontext primaryContext
+    cydriver.CUdevice driverDevice
+    cydriver.CUcontext primaryContext
     bool primaryContextRetained
     int deviceOrdinal
     cudaDeviceProp deviceProperties
@@ -27,47 +27,47 @@ cdef class cudaPythonGlobal:
 
     cdef cudaError_t lazyInitDriver(self) except ?cudaErrorCallRequiresNewerDriver nogil
     cdef cudaError_t lazyInitContextState(self) except ?cudaErrorCallRequiresNewerDriver nogil
-    cdef cudaPythonDevice* getDevice(self, int deviceOrdinal) nogil
-    cdef cudaPythonDevice* getDeviceFromDriver(self, ccuda.CUdevice driverDevice) nogil
-    cdef cudaPythonDevice* getDeviceFromPrimaryCtx(self, ccuda.CUcontext context) nogil
+    cdef cudaPythonDevice* getDevice(self, int deviceOrdinal) noexcept nogil
+    cdef cudaPythonDevice* getDeviceFromDriver(self, cydriver.CUdevice driverDevice) noexcept nogil
+    cdef cudaPythonDevice* getDeviceFromPrimaryCtx(self, cydriver.CUcontext context) noexcept nogil
 
 cdef cudaError_t initPrimaryContext(cudaPythonDevice *device) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t resetPrimaryContext(cudaPythonDevice* device) except ?cudaErrorCallRequiresNewerDriver nogil
 
 cdef cudaPythonGlobal globalGetInstance()
 cdef cudaError_t _setLastError(cudaError_t err) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChannels, ccuda.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChannels, cydriver.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t streamAddCallbackCommon(cudaStream_t stream, cudaStreamCallback_t callback, void *userData, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t streamGetCaptureInfoCommon(cudaStream_t stream, cudaStreamCaptureStatus* captureStatus_out, unsigned long long *id_out, cudaGraph_t *graph_out, const cudaGraphNode_t **dependencies_out, size_t *numDependencies_out) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getChannelFormatDescFromDriverDesc(cudaChannelFormatDesc* pRuntimeDesc, size_t* pDepth, size_t* pHeight, size_t* pWidth, const ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2* pDriverDesc) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyFromHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t spitch, size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyFromDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset,
-                                  size_t spitch, size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getChannelFormatDescFromDriverDesc(cudaChannelFormatDesc* pRuntimeDesc, size_t* pDepth, size_t* pHeight, size_t* pWidth, const cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2* pDriverDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyFromHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t spitch, size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyFromDevice2D(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset,
+                                  size_t spitch, size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t copyToHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t dpitch, size_t width,
-                              size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyToDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t dpitch,
-                                size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+                              size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyToDevice2D(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t dpitch,
+                                size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t copyToArray2D(cudaArray_const_t thisArray, size_t hOffsetSrc, size_t wOffsetSrc, cudaArray_t dst,
                                size_t hOffsetDst, size_t wOffsetDst, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t getChannelDesc(cudaArray_const_t thisArray, cudaChannelFormatDesc *outDesc) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, const cudaResourceDesc *rdSrc,
-                                             ccuda.CUDA_TEXTURE_DESC *tdDst, const cudaTextureDesc_v2 *tdSrc,
-                                             ccuda.CUDA_RESOURCE_VIEW_DESC *rvdDst, const cudaResourceViewDesc *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const ccuda.CUDA_RESOURCE_DESC *rdSrc,
-                                             cudaTextureDesc_v2 *tdDst, const ccuda.CUDA_TEXTURE_DESC *tdSrc,
-                                             cudaResourceViewDesc *rvdDst, const ccuda.CUDA_RESOURCE_VIEW_DESC *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getDriverResDescFromResDesc(cydriver.CUDA_RESOURCE_DESC *rdDst, const cudaResourceDesc *rdSrc,
+                                             cydriver.CUDA_TEXTURE_DESC *tdDst, const cudaTextureDesc_v2 *tdSrc,
+                                             cydriver.CUDA_RESOURCE_VIEW_DESC *rvdDst, const cudaResourceViewDesc *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const cydriver.CUDA_RESOURCE_DESC *rdSrc,
+                                             cudaTextureDesc_v2 *tdDst, const cydriver.CUDA_TEXTURE_DESC *tdSrc,
+                                             cudaResourceViewDesc *rvdDst, const cydriver.CUDA_RESOURCE_VIEW_DESC *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memsetPtr(char *mem, int c, size_t count, cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memset2DPtr(char *mem, size_t pitch, int c, size_t width, size_t height, cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t copyFromHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t count,
-                              ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyFromDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset,
-                                const char *src, size_t srcOffset, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyToHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t copyToDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset,
-                              const char *dst, size_t dstOffset, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+                              cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyFromDevice(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset,
+                                const char *src, size_t srcOffset, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyToHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t copyToDevice(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset,
+                              const char *dst, size_t dstOffset, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t copy1DConvertTo3DParams(void* dst, const void* src, size_t count, cudaMemcpyKind kind, cudaMemcpy3DParms *p) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef void toDriverMemsetNodeParams(const cudaMemsetParams *pRuntimeParams, ccuda.CUDA_MEMSET_NODE_PARAMS *pDriverParams) nogil
-cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_MEMCPY3D *cd) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef void toDriverMemsetNodeParams(const cudaMemsetParams *pRuntimeParams, cydriver.CUDA_MEMSET_NODE_PARAMS *pDriverParams) noexcept nogil
+cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, cydriver.CUDA_MEMCPY3D *cd) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t mallocArray(cudaArray_t *arrayPtr, const cudaChannelFormatDesc *desc, size_t depth, size_t height,
                              size_t width, int corr2D, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memcpy2DToArray(cudaArray_t dst, size_t hOffset, size_t wOffset, const char *src,
@@ -83,7 +83,7 @@ cdef cudaError_t memcpy2DPtr(char *dst, size_t dpitch, const char *src, size_t s
                              cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memcpy3D(const cudaMemcpy3DParms *p, bool peer, int srcDevice, int dstDevice, cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memcpyAsyncDispatch(void *dst, const void *src, size_t size, cudaMemcpyKind kind, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaMemcpy3DParms *p) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t toCudartMemCopy3DParams(const cydriver.CUDA_MEMCPY3D_v2 *cd, cudaMemcpy3DParms *p) except ?cudaErrorCallRequiresNewerDriver nogil
 cdef cudaError_t memcpy2DFromArray(char *dst, size_t dpitch, cudaArray_const_t src, size_t hOffset,
                                    size_t wOffset, size_t width, size_t height, cudaMemcpyKind kind,
                                    cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil
@@ -100,6 +100,6 @@ cdef cudaError_t memcpyFromArray(char *dst, cudaArray_const_t src, size_t hOffse
 cdef cudaError_t memcpyArrayToArray(cudaArray_t dst, size_t hOffsetDst, size_t wOffsetDst,
                                     cudaArray_const_t src, size_t hOffsetSrc, size_t wOffsetSrc,
                                     size_t count, cudaMemcpyKind kind) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t toDriverCudaResourceDesc(ccuda.CUDA_RESOURCE_DESC *_driver_pResDesc, const cudaResourceDesc *pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getDriverEglFrame(ccuda.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil
-cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, ccuda.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t toDriverCudaResourceDesc(cydriver.CUDA_RESOURCE_DESC *_driver_pResDesc, const cudaResourceDesc *pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil
diff --git a/cuda/_lib/ccudart/utils.pyx.in b/cuda/cuda/bindings/_lib/cyruntime/utils.pyx.in
similarity index 51%
rename from cuda/_lib/ccudart/utils.pyx.in
rename to cuda/cuda/bindings/_lib/cyruntime/utils.pyx.in
index 134ed136..6b1b6d82 100644
--- a/cuda/_lib/ccudart/utils.pyx.in
+++ b/cuda/cuda/bindings/_lib/cyruntime/utils.pyx.in
@@ -5,14 +5,15 @@
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-from cuda.ccudart cimport *
+import cython
+from cuda.bindings.cyruntime cimport *
 from libc.stdlib cimport malloc, free, calloc
 from libc.string cimport memset, memcpy, strncmp
 from libcpp cimport bool
-cimport cuda._cuda.ccuda as ccuda
+cimport cuda.bindings._bindings.cydriver as cydriver
 
 cdef struct cudaArrayLocalState:
-    ccuda.CUarray array
+    cydriver.CUarray array
     cudaChannelFormatDesc desc
     size_t depth
     size_t height
@@ -42,10 +43,10 @@ cdef class cudaPythonGlobal:
             return cudaSuccess
 
         cdef cudaError_t err = cudaSuccess
-        err = <cudaError_t>ccuda._cuInit(0)
+        err = <cudaError_t>cydriver._cuInit(0)
         if err != cudaSuccess:
             return err
-        err = <cudaError_t>ccuda._cuDeviceGetCount(&self._numDevices)
+        err = <cudaError_t>cydriver._cuDeviceGetCount(&self._numDevices)
         if err != cudaSuccess:
             return err
 
@@ -63,14 +64,14 @@ cdef class cudaPythonGlobal:
 
     cdef cudaError_t lazyInitContextState(self) except ?cudaErrorCallRequiresNewerDriver nogil:
         cdef cudaError_t err = cudaSuccess
-        cdef ccuda.CUcontext driverContext
+        cdef cydriver.CUcontext driverContext
         cdef cudaPythonDevice *device
 
         err = self.lazyInitDriver()
         if err != cudaSuccess:
             return err
 
-        err = <cudaError_t>ccuda._cuCtxGetCurrent(&driverContext)
+        err = <cudaError_t>cydriver._cuCtxGetCurrent(&driverContext)
         if err != cudaSuccess:
             return err
         device = self.getDeviceFromPrimaryCtx(driverContext)
@@ -86,7 +87,7 @@ cdef class cudaPythonGlobal:
         if driverContext != NULL:
             # If the context exists, but is non-primary, make sure it can be used with the CUDA 3.2 API,
             # then return immediately
-            err = <cudaError_t>ccuda._cuCtxGetApiVersion(driverContext, &version)
+            err = <cudaError_t>cydriver._cuCtxGetApiVersion(driverContext, &version)
             if err == cudaErrorContextIsDestroyed:
                 return cudaErrorIncompatibleDriverContext
             elif err != cudaSuccess:
@@ -104,21 +105,21 @@ cdef class cudaPythonGlobal:
         err = initPrimaryContext(device)
         if err != cudaSuccess:
             return err
-        err = <cudaError_t> ccuda._cuCtxSetCurrent(device.primaryContext)
+        err = <cudaError_t> cydriver._cuCtxSetCurrent(device.primaryContext)
         return err
 
-    cdef cudaPythonDevice* getDevice(self, int deviceOrdinal) nogil:
+    cdef cudaPythonDevice* getDevice(self, int deviceOrdinal) noexcept nogil:
         if deviceOrdinal < 0 or deviceOrdinal >= m_global._numDevices:
             return NULL
         return &self._deviceList[deviceOrdinal]
 
-    cdef cudaPythonDevice* getDeviceFromDriver(self, ccuda.CUdevice driverDevice) nogil:
+    cdef cudaPythonDevice* getDeviceFromDriver(self, cydriver.CUdevice driverDevice) noexcept nogil:
         for i in range(self._numDevices):
             if self._deviceList[i].driverDevice == driverDevice:
                 return &self._deviceList[i]
         return NULL
 
-    cdef cudaPythonDevice* getDeviceFromPrimaryCtx(self, ccuda.CUcontext context) nogil:
+    cdef cudaPythonDevice* getDeviceFromPrimaryCtx(self, cydriver.CUcontext context) noexcept nogil:
         if context == NULL:
             return NULL
         for i in range(self._numDevices):
@@ -130,424 +131,424 @@ cdef cudaPythonGlobal m_global = cudaPythonGlobal()
 
 
 cdef cudaError_t initDevice(cudaPythonDevice *device, int deviceOrdinal) except ?cudaErrorCallRequiresNewerDriver nogil:
-    # ccuda.CUcontext primaryContext
+    # cydriver.CUcontext primaryContext
     device[0].primaryContext = NULL
     # bool primaryContextRetained
     device[0].primaryContextRetained = False
     # int deviceOrdinal
     device[0].deviceOrdinal = deviceOrdinal
 
-    # ccuda.CUdevice driverDevice
-    err = ccuda._cuDeviceGet(&device[0].driverDevice, deviceOrdinal)
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    # cydriver.CUdevice driverDevice
+    err = cydriver._cuDeviceGet(&device[0].driverDevice, deviceOrdinal)
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     # cudaDeviceProp deviceProperties
-    err = ccuda._cuDeviceGetName(device[0].deviceProperties.name, sizeof(device[0].deviceProperties.name), <ccuda.CUdevice>deviceOrdinal)
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetName(device[0].deviceProperties.name, sizeof(device[0].deviceProperties.name), <cydriver.CUdevice>deviceOrdinal)
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceTotalMem_v2(&(device[0].deviceProperties.totalGlobalMem), <ccuda.CUdevice>deviceOrdinal)
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceTotalMem_v2(&(device[0].deviceProperties.totalGlobalMem), <cydriver.CUdevice>deviceOrdinal)
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceTotalMem_v2(&(device[0].deviceProperties.totalGlobalMem), <ccuda.CUdevice>deviceOrdinal)
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceTotalMem_v2(&(device[0].deviceProperties.totalGlobalMem), <cydriver.CUdevice>deviceOrdinal)
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.major), ccuda.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.major), cydriver.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.minor), ccuda.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.minor), cydriver.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.deviceOverlap), ccuda.CU_DEVICE_ATTRIBUTE_GPU_OVERLAP, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.deviceOverlap), cydriver.CU_DEVICE_ATTRIBUTE_GPU_OVERLAP, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.asyncEngineCount), ccuda.CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.asyncEngineCount), cydriver.CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.multiProcessorCount), ccuda.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.multiProcessorCount), cydriver.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.kernelExecTimeoutEnabled), ccuda.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.kernelExecTimeoutEnabled), cydriver.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.integrated), ccuda.CU_DEVICE_ATTRIBUTE_INTEGRATED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.integrated), cydriver.CU_DEVICE_ATTRIBUTE_INTEGRATED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.canMapHostMemory), ccuda.CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.canMapHostMemory), cydriver.CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1D), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1D), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DMipmap), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DMipmap), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLinear), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLinear), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2D[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2D[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2D[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2D[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DMipmap[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DMipmap[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DMipmap[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DMipmap[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLinear[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DGather[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DGather[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DGather[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DGather[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3D[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture3DAlt[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemap), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemap), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture1DLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTexture2DLayered[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemapLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemapLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemapLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxTextureCubemapLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1D), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1D), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2D[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2D[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2D[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2D[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface3D[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1DLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1DLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1DLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface1DLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurface2DLayered[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemap), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemap), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemapLayered[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemapLayered[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemapLayered[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxSurfaceCubemapLayered[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.concurrentKernels), ccuda.CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.concurrentKernels), cydriver.CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.ECCEnabled), ccuda.CU_DEVICE_ATTRIBUTE_ECC_ENABLED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.ECCEnabled), cydriver.CU_DEVICE_ATTRIBUTE_ECC_ENABLED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.pciBusID), ccuda.CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.pciBusID), cydriver.CU_DEVICE_ATTRIBUTE_PCI_BUS_ID, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.pciDeviceID), ccuda.CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.pciDeviceID), cydriver.CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.pciDomainID), ccuda.CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.pciDomainID), cydriver.CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.tccDriver), ccuda.CU_DEVICE_ATTRIBUTE_TCC_DRIVER, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.tccDriver), cydriver.CU_DEVICE_ATTRIBUTE_TCC_DRIVER, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.unifiedAddressing), ccuda.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.unifiedAddressing), cydriver.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryClockRate), ccuda.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryClockRate), cydriver.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryBusWidth), ccuda.CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.memoryBusWidth), cydriver.CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.l2CacheSize), ccuda.CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.l2CacheSize), cydriver.CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.persistingL2CacheMaxSize), ccuda.CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.persistingL2CacheMaxSize), cydriver.CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsPerMultiProcessor), ccuda.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsPerMultiProcessor), cydriver.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     cdef int surfaceAlignment
-    err = ccuda._cuDeviceGetAttribute(&(surfaceAlignment), ccuda.CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(surfaceAlignment), cydriver.CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.surfaceAlignment = surfaceAlignment
 
     cdef int texturePitchAlignment
-    err = ccuda._cuDeviceGetAttribute(&texturePitchAlignment, ccuda.CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&texturePitchAlignment, cydriver.CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.texturePitchAlignment = texturePitchAlignment
 
     cdef int sharedMemPerBlock
-    err = ccuda._cuDeviceGetAttribute(&sharedMemPerBlock, ccuda.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&sharedMemPerBlock, cydriver.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.sharedMemPerBlock = sharedMemPerBlock
 
     cdef int sharedMemPerBlockOptin
-    err = ccuda._cuDeviceGetAttribute(&sharedMemPerBlockOptin, ccuda.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&sharedMemPerBlockOptin, cydriver.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.sharedMemPerBlockOptin = sharedMemPerBlockOptin
 
     cdef int sharedMemPerMultiprocessor
-    err = ccuda._cuDeviceGetAttribute(&sharedMemPerMultiprocessor, ccuda.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&sharedMemPerMultiprocessor, cydriver.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.sharedMemPerMultiprocessor = sharedMemPerMultiprocessor
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.regsPerBlock), ccuda.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.regsPerBlock), cydriver.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.regsPerMultiprocessor), ccuda.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.regsPerMultiprocessor), cydriver.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.warpSize), ccuda.CU_DEVICE_ATTRIBUTE_WARP_SIZE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.warpSize), cydriver.CU_DEVICE_ATTRIBUTE_WARP_SIZE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     cdef int memPitch
-    err = ccuda._cuDeviceGetAttribute(&memPitch, ccuda.CU_DEVICE_ATTRIBUTE_MAX_PITCH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&memPitch, cydriver.CU_DEVICE_ATTRIBUTE_MAX_PITCH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.memPitch = memPitch
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsPerBlock), ccuda.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsPerBlock), cydriver.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxThreadsDim[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[0]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[0]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[1]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[1]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[2]), ccuda.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxGridSize[2]), cydriver.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     cdef int totalConstMem
-    err = ccuda._cuDeviceGetAttribute(&totalConstMem, ccuda.CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&totalConstMem, cydriver.CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.totalConstMem = totalConstMem
 
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.clockRate), ccuda.CU_DEVICE_ATTRIBUTE_CLOCK_RATE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.clockRate), cydriver.CU_DEVICE_ATTRIBUTE_CLOCK_RATE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     cdef int textureAlignment
-    err = ccuda._cuDeviceGetAttribute(&textureAlignment, ccuda.CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&textureAlignment, cydriver.CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.textureAlignment = textureAlignment
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.streamPrioritiesSupported), ccuda.CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.streamPrioritiesSupported), cydriver.CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.globalL1CacheSupported), ccuda.CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.globalL1CacheSupported), cydriver.CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.localL1CacheSupported), ccuda.CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.localL1CacheSupported), cydriver.CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.managedMemory), ccuda.CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.managedMemory), cydriver.CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.isMultiGpuBoard), ccuda.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.isMultiGpuBoard), cydriver.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.multiGpuBoardGroupID), ccuda.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.multiGpuBoardGroupID), cydriver.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.hostNativeAtomicSupported), ccuda.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.hostNativeAtomicSupported), cydriver.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.singleToDoublePrecisionPerfRatio), ccuda.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.singleToDoublePrecisionPerfRatio), cydriver.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.pageableMemoryAccess), ccuda.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.pageableMemoryAccess), cydriver.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.concurrentManagedAccess), ccuda.CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.concurrentManagedAccess), cydriver.CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.computePreemptionSupported), ccuda.CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.computePreemptionSupported), cydriver.CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.canUseHostPointerForRegisteredMem), ccuda.CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.canUseHostPointerForRegisteredMem), cydriver.CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.cooperativeLaunch), ccuda.CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.cooperativeLaunch), cydriver.CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.cooperativeMultiDeviceLaunch), ccuda.CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.cooperativeMultiDeviceLaunch), cydriver.CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.pageableMemoryAccessUsesHostPageTables), ccuda.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.pageableMemoryAccessUsesHostPageTables), cydriver.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.directManagedMemAccessFromHost), ccuda.CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.directManagedMemAccessFromHost), cydriver.CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
-    err = ccuda._cuDeviceGetUuid(<ccuda.CUuuid_st*>(&(device[0].deviceProperties.uuid)), <ccuda.CUdevice>deviceOrdinal)
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetUuid(<cydriver.CUuuid_st*>(&(device[0].deviceProperties.uuid)), <cydriver.CUdevice>deviceOrdinal)
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.maxBlocksPerMultiProcessor), ccuda.CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.maxBlocksPerMultiProcessor), cydriver.CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
-    err = ccuda._cuDeviceGetAttribute(&(device[0].deviceProperties.accessPolicyMaxWindowSize), ccuda.CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&(device[0].deviceProperties.accessPolicyMaxWindowSize), cydriver.CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
 
     cdef int reservedSharedMemPerBlock
-    err = ccuda._cuDeviceGetAttribute(&reservedSharedMemPerBlock, ccuda.CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, <ccuda.CUdevice>(deviceOrdinal))
-    if err != ccuda.cudaError_enum.CUDA_SUCCESS:
+    err = cydriver._cuDeviceGetAttribute(&reservedSharedMemPerBlock, cydriver.CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK, <cydriver.CUdevice>(deviceOrdinal))
+    if err != cydriver.cudaError_enum.CUDA_SUCCESS:
         return cudaErrorInitializationError
     device[0].deviceProperties.reservedSharedMemPerBlock = reservedSharedMemPerBlock
 
@@ -560,9 +561,9 @@ cdef cudaError_t initPrimaryContext(cudaPythonDevice *device) except ?cudaErrorC
     # If we have context retained we need to check if it is not reset
     cdef unsigned int version
     if device[0].primaryContextRetained:
-        err = <cudaError_t>ccuda._cuCtxGetApiVersion(device[0].primaryContext, &version)
+        err = <cudaError_t>cydriver._cuCtxGetApiVersion(device[0].primaryContext, &version)
         if err == cudaErrorDeviceUninitialized:
-            err = <cudaError_t>ccuda.cuDevicePrimaryCtxRelease(device[0].driverDevice)
+            err = <cudaError_t>cydriver.cuDevicePrimaryCtxRelease(device[0].driverDevice)
             if err != cudaSuccess:
                 return err
             device[0].primaryContextRetained = False
@@ -571,7 +572,7 @@ cdef cudaError_t initPrimaryContext(cudaPythonDevice *device) except ?cudaErrorC
 
     # If we don't or it is invalid we need to recreate it
     if not device[0].primaryContextRetained:
-        err = <cudaError_t>ccuda._cuDevicePrimaryCtxRetain(&device[0].primaryContext, device[0].driverDevice)
+        err = <cudaError_t>cydriver._cuDevicePrimaryCtxRetain(&device[0].primaryContext, device[0].driverDevice)
         if err != cudaSuccess:
             return err
         device[0].primaryContextRetained = True
@@ -581,14 +582,14 @@ cdef cudaError_t resetPrimaryContext(cudaPythonDevice* device) except ?cudaError
     cdef cudaError_t err = cudaSuccess
     cdef unsigned int version
 
-    err = <cudaError_t>ccuda._cuCtxGetApiVersion(device[0].primaryContext, &version)
+    err = <cudaError_t>cydriver._cuCtxGetApiVersion(device[0].primaryContext, &version)
     if err == cudaSuccess:
         if not device[0].primaryContextRetained:
-            err = <cudaError_t>ccuda._cuDevicePrimaryCtxRetain(&device[0].primaryContext, device[0].driverDevice)
+            err = <cudaError_t>cydriver._cuDevicePrimaryCtxRetain(&device[0].primaryContext, device[0].driverDevice)
             if err != cudaSuccess:
                 return err
             device[0].primaryContextRetained = True
-        ccuda._cuDevicePrimaryCtxReset_v2(device[0].driverDevice)
+        cydriver._cuDevicePrimaryCtxReset_v2(device[0].driverDevice)
         return cudaSuccess
     elif err == cudaErrorDeviceUninitialized:
         return cudaSuccess
@@ -609,7 +610,7 @@ cdef int case_desc(const cudaChannelFormatDesc* d, int x, int y, int z, int w, i
     return d[0].x == x and d[0].y == y and d[0].z == z and d[0].w == w and d[0].f == f
 
 
-cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChannels, ccuda.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChannels, cydriver.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil:
     # Check validity
     if d[0].f in (cudaChannelFormatKind.cudaChannelFormatKindSigned,
                   cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
@@ -667,145 +668,145 @@ cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChanne
         return cudaErrorInvalidChannelDescriptor
     if case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
     elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
     elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8
     elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
     elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
     elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8
     elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
     elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
     elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
     elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16
     elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
     elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
     elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
     elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16
     elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
     elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
     elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
     elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindSigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32
     elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
     elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
     elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
     elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindUnsigned):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32
     elif case_desc(d, 16, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_HALF
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF
     elif case_desc(d, 16, 16, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_HALF
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF
     elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_HALF
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF
     elif case_desc(d, 16, 16, 16, 16, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_HALF
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF
     elif case_desc(d, 32, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_FLOAT
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT
     elif case_desc(d, 32, 32, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_FLOAT
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT
     elif case_desc(d, 32, 32, 32, 0, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_FLOAT
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT
     elif case_desc(d, 32, 32, 32, 32, cudaChannelFormatKind.cudaChannelFormatKindFloat):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_FLOAT
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT
     elif case_desc(d, 8, 8, 8, 0, cudaChannelFormatKind.cudaChannelFormatKindNV12):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_NV12
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_NV12
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM_SRGB
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM_SRGB
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM_SRGB
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM_SRGB
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM_SRGB
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM_SRGB
     elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC4_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_UNORM
     elif case_desc(d, 8, 0, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4):
         numberOfChannels[0] = 1
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC4_SNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_SNORM
     elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC5_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_UNORM
     elif case_desc(d, 8, 8, 0, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5):
         numberOfChannels[0] = 2
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC5_SNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_SNORM
     elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC6H_UF16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_UF16
     elif case_desc(d, 16, 16, 16, 0, cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H):
         numberOfChannels[0] = 3
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC6H_SF16
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_SF16
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM
     elif case_desc(d, 8, 8, 8, 8, cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB):
         numberOfChannels[0] = 4
-        format[0] = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM_SRGB
+        format[0] = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM_SRGB
     else:
         return cudaErrorInvalidChannelDescriptor
 
@@ -820,8 +821,8 @@ cdef cudaError_t getDescInfo(const cudaChannelFormatDesc* d, int *numberOfChanne
     return cudaSuccess
 
 
-#TODO: Check return type of this method CUDA_CB
-cdef void cudaStreamRtCallbackWrapper(ccuda.CUstream stream, ccuda.CUresult status, void *data) nogil:
+@cython.show_performance_hints(False)
+cdef void cudaStreamRtCallbackWrapper(cydriver.CUstream stream, cydriver.CUresult status, void *data) nogil:
     cdef cudaStreamCallbackData *cbData = <cudaStreamCallbackData *>data
     cdef cudaError_t err = <cudaError_t>status
     with gil:
@@ -839,7 +840,7 @@ cdef cudaError_t streamAddCallbackCommon(
         return cudaErrorInvalidValue
 
     cdef cudaStreamCallbackData *cbData = NULL
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     cbData = <cudaStreamCallbackData *>malloc(sizeof(cbData[0]))
 
     if cbData == NULL:
@@ -847,18 +848,18 @@ cdef cudaError_t streamAddCallbackCommon(
 
     cbData.callback = callback
     cbData.userData = userData
-    err = <cudaError_t>ccuda._cuStreamAddCallback(stream, <ccuda.CUstreamCallback>cudaStreamRtCallbackWrapper, <void *>cbData, flags)
+    err = <cudaError_t>cydriver._cuStreamAddCallback(stream, <cydriver.CUstreamCallback>cudaStreamRtCallbackWrapper, <void *>cbData, flags)
     if err != cudaSuccess:
         free(cbData)
     return err
 
 
-cdef cudaError_t toRuntimeStreamCaptureStatus(ccuda.CUstreamCaptureStatus driverCaptureStatus, cudaStreamCaptureStatus *runtimeStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if driverCaptureStatus == ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_NONE:
+cdef cudaError_t toRuntimeStreamCaptureStatus(cydriver.CUstreamCaptureStatus driverCaptureStatus, cudaStreamCaptureStatus *runtimeStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if driverCaptureStatus == cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_NONE:
         runtimeStatus[0] = cudaStreamCaptureStatus.cudaStreamCaptureStatusNone
-    elif driverCaptureStatus == ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_ACTIVE:
+    elif driverCaptureStatus == cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_ACTIVE:
         runtimeStatus[0] = cudaStreamCaptureStatus.cudaStreamCaptureStatusActive
-    elif driverCaptureStatus == ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_INVALIDATED:
+    elif driverCaptureStatus == cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_INVALIDATED:
         runtimeStatus[0] = cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated
     else:
          return cudaErrorUnknown
@@ -866,35 +867,34 @@ cdef cudaError_t toRuntimeStreamCaptureStatus(ccuda.CUstreamCaptureStatus driver
 
 
 cdef cudaError_t streamGetCaptureInfoCommon(
-  cudaStream_t stream,
-  cudaStreamCaptureStatus* captureStatus_out,
-  unsigned long long *id_out,
-  cudaGraph_t *graph_out,
-  const cudaGraphNode_t **dependencies_out,
-  size_t *numDependencies_out,
-)  except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
+        cudaStream_t stream,
+        cudaStreamCaptureStatus* captureStatus_out,
+        unsigned long long *id_out,
+        cudaGraph_t *graph_out,
+        const cudaGraphNode_t **dependencies_out,
+        size_t *numDependencies_out)  except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
 
     if captureStatus_out == NULL:
         return cudaErrorInvalidValue
 
-    cdef ccuda.CUstreamCaptureStatus driverCaptureStatus
+    cdef cydriver.CUstreamCaptureStatus driverCaptureStatus
 
     if graph_out or dependencies_out or numDependencies_out:
-        err = <cudaError_t>ccuda._cuStreamGetCaptureInfo_v2(stream, &driverCaptureStatus, <ccuda.cuuint64_t*>id_out,
+        err = <cudaError_t>cydriver._cuStreamGetCaptureInfo_v2(stream, &driverCaptureStatus, <cydriver.cuuint64_t*>id_out,
                 graph_out, dependencies_out, numDependencies_out)
         if err != cudaSuccess:
             return err
     else:
-        err = <cudaError_t>ccuda._cuStreamGetCaptureInfo(stream, &driverCaptureStatus, <ccuda.cuuint64_t*>id_out)
+        err = <cudaError_t>cydriver._cuStreamGetCaptureInfo(stream, &driverCaptureStatus, <cydriver.cuuint64_t*>id_out)
         if err != cudaSuccess:
             return err
 
     return toRuntimeStreamCaptureStatus(driverCaptureStatus, captureStatus_out)
 
 
-cdef ccuda.CUDA_MEMCPY3D_v2 memCopy3DInit(ccuda.CUmemorytype_enum dstType, ccuda.CUmemorytype_enum srcType) nogil:
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp
+cdef cydriver.CUDA_MEMCPY3D_v2 memCopy3DInit(cydriver.CUmemorytype_enum dstType, cydriver.CUmemorytype_enum srcType) noexcept nogil:
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp
     memset(&cp, 0, sizeof(cp))
     cp.dstMemoryType = dstType
     cp.srcMemoryType = srcType
@@ -904,8 +904,8 @@ cdef ccuda.CUDA_MEMCPY3D_v2 memCopy3DInit(ccuda.CUmemorytype_enum dstType, ccuda
     return cp
 
 
-cdef ccuda.CUDA_MEMCPY2D_v2 memCopy2DInit(ccuda.CUmemorytype_enum dstType, ccuda.CUmemorytype_enum srcType) nogil:
-    cdef ccuda.CUDA_MEMCPY2D_v2 cp
+cdef cydriver.CUDA_MEMCPY2D_v2 memCopy2DInit(cydriver.CUmemorytype_enum dstType, cydriver.CUmemorytype_enum srcType) noexcept nogil:
+    cdef cydriver.CUDA_MEMCPY2D_v2 cp
     memset(&cp, 0, sizeof(cp))
     cp.dstMemoryType = dstType
     cp.srcMemoryType = srcType
@@ -914,52 +914,52 @@ cdef ccuda.CUDA_MEMCPY2D_v2 memCopy2DInit(ccuda.CUmemorytype_enum dstType, ccuda
     return cp
 
 
-cdef cudaError_t bytesPerElement(size_t *bytes, int numberOfChannels, ccuda.CUarray_format format) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if format in (ccuda.CU_AD_FORMAT_FLOAT,
-                  ccuda.CU_AD_FORMAT_UNSIGNED_INT32,
-                  ccuda.CU_AD_FORMAT_SIGNED_INT32):
+cdef cudaError_t bytesPerElement(size_t *bytes, int numberOfChannels, cydriver.CUarray_format format) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if format in (cydriver.CU_AD_FORMAT_FLOAT,
+                  cydriver.CU_AD_FORMAT_UNSIGNED_INT32,
+                  cydriver.CU_AD_FORMAT_SIGNED_INT32):
         bytes[0] = numberOfChannels * 4
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_HALF,
-                    ccuda.CU_AD_FORMAT_SIGNED_INT16,
-                    ccuda.CU_AD_FORMAT_UNSIGNED_INT16):
+    elif format in (cydriver.CU_AD_FORMAT_HALF,
+                    cydriver.CU_AD_FORMAT_SIGNED_INT16,
+                    cydriver.CU_AD_FORMAT_UNSIGNED_INT16):
         bytes[0] = numberOfChannels * 2
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_SIGNED_INT8,
-                    ccuda.CU_AD_FORMAT_UNSIGNED_INT8,
-                    ccuda.CU_AD_FORMAT_NV12):
+    elif format in (cydriver.CU_AD_FORMAT_SIGNED_INT8,
+                    cydriver.CU_AD_FORMAT_UNSIGNED_INT8,
+                    cydriver.CU_AD_FORMAT_NV12):
         bytes[0] = numberOfChannels
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_SNORM_INT8X1,
-                    ccuda.CU_AD_FORMAT_UNORM_INT8X1):
+    elif format in (cydriver.CU_AD_FORMAT_SNORM_INT8X1,
+                    cydriver.CU_AD_FORMAT_UNORM_INT8X1):
         bytes[0] = 1
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_SNORM_INT8X2,
-                    ccuda.CU_AD_FORMAT_UNORM_INT8X2,
-                    ccuda.CU_AD_FORMAT_SNORM_INT16X1,
-                    ccuda.CU_AD_FORMAT_UNORM_INT16X1):
+    elif format in (cydriver.CU_AD_FORMAT_SNORM_INT8X2,
+                    cydriver.CU_AD_FORMAT_UNORM_INT8X2,
+                    cydriver.CU_AD_FORMAT_SNORM_INT16X1,
+                    cydriver.CU_AD_FORMAT_UNORM_INT16X1):
         bytes[0] = 2
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_SNORM_INT8X4,
-                    ccuda.CU_AD_FORMAT_UNORM_INT8X4,
-                    ccuda.CU_AD_FORMAT_SNORM_INT16X2,
-                    ccuda.CU_AD_FORMAT_UNORM_INT16X2):
+    elif format in (cydriver.CU_AD_FORMAT_SNORM_INT8X4,
+                    cydriver.CU_AD_FORMAT_UNORM_INT8X4,
+                    cydriver.CU_AD_FORMAT_SNORM_INT16X2,
+                    cydriver.CU_AD_FORMAT_UNORM_INT16X2):
         bytes[0] = 4
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_SNORM_INT16X4,
-                    ccuda.CU_AD_FORMAT_UNORM_INT16X4):
+    elif format in (cydriver.CU_AD_FORMAT_SNORM_INT16X4,
+                    cydriver.CU_AD_FORMAT_UNORM_INT16X4):
         bytes[0] = 8
         return cudaSuccess
-    elif format in (ccuda.CU_AD_FORMAT_BC2_UNORM,
-                    ccuda.CU_AD_FORMAT_BC2_UNORM_SRGB,
-                    ccuda.CU_AD_FORMAT_BC3_UNORM,
-                    ccuda.CU_AD_FORMAT_BC3_UNORM_SRGB,
-                    ccuda.CU_AD_FORMAT_BC5_UNORM,
-                    ccuda.CU_AD_FORMAT_BC5_SNORM,
-                    ccuda.CU_AD_FORMAT_BC6H_UF16,
-                    ccuda.CU_AD_FORMAT_BC6H_SF16,
-                    ccuda.CU_AD_FORMAT_BC7_UNORM,
-                    ccuda.CU_AD_FORMAT_BC7_UNORM_SRGB):
+    elif format in (cydriver.CU_AD_FORMAT_BC2_UNORM,
+                    cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB,
+                    cydriver.CU_AD_FORMAT_BC3_UNORM,
+                    cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB,
+                    cydriver.CU_AD_FORMAT_BC5_UNORM,
+                    cydriver.CU_AD_FORMAT_BC5_SNORM,
+                    cydriver.CU_AD_FORMAT_BC6H_UF16,
+                    cydriver.CU_AD_FORMAT_BC6H_SF16,
+                    cydriver.CU_AD_FORMAT_BC7_UNORM,
+                    cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB):
         bytes[0] = 16
         return cudaSuccess
     return cudaErrorInvalidChannelDescriptor
@@ -967,112 +967,112 @@ cdef cudaError_t bytesPerElement(size_t *bytes, int numberOfChannels, ccuda.CUar
 
 cdef cudaError_t getChannelFormatDescFromDriverDesc(
     cudaChannelFormatDesc* pRuntimeDesc, size_t* pDepth, size_t* pHeight, size_t* pWidth,
-    const ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2* pDriverDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+    const cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2* pDriverDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
 
     cdef int channel_size = 0
-    if pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT8:
+    if pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT8:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT16:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT16:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT32:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT32:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsigned
         channel_size = 32
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SIGNED_INT8:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT8:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SIGNED_INT16:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT16:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SIGNED_INT32:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SIGNED_INT32:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSigned
         channel_size = 32
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_HALF:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_HALF:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindFloat
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_FLOAT:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_FLOAT:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindFloat
         channel_size = 32
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_NV12:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_NV12:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindNV12
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT8X1:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X1:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT8X2:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X2:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT8X4:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT8X4:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT8X1:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X1:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT8X2:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X2:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT8X4:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT8X4:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT16X1:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X1:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT16X2:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X2:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_UNORM_INT16X4:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_UNORM_INT16X4:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT16X1:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X1:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT16X2:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X2:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_SNORM_INT16X4:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_SNORM_INT16X4:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC1_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC1_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC1_UNORM_SRGB:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC1_UNORM_SRGB:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC2_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC2_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC2_UNORM_SRGB:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC3_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC3_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC3_UNORM_SRGB:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC4_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC4_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC4_SNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC4_SNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC5_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC5_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC5_SNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC5_SNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC6H_UF16:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC6H_UF16:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC6H_SF16:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC6H_SF16:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H
         channel_size = 16
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC7_UNORM:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC7_UNORM:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7
         channel_size = 8
-    elif pDriverDesc[0].Format == ccuda.CU_AD_FORMAT_BC7_UNORM_SRGB:
+    elif pDriverDesc[0].Format == cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB:
         pRuntimeDesc[0].f = cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB
         channel_size = 8
     else:
@@ -1106,45 +1106,45 @@ cdef cudaError_t getChannelFormatDescFromDriverDesc(
     return cudaSuccess
 
 
-cdef cudaError_t getArrayBlockExtent(cudaExtent *blockExtent, ccuda.CUarray_format format) except ?cudaErrorCallRequiresNewerDriver nogil:
-    if format in (ccuda.CU_AD_FORMAT_FLOAT,
-                  ccuda.CU_AD_FORMAT_UNSIGNED_INT32,
-                  ccuda.CU_AD_FORMAT_SIGNED_INT32,
-                  ccuda.CU_AD_FORMAT_HALF,
-                  ccuda.CU_AD_FORMAT_SIGNED_INT16,
-                  ccuda.CU_AD_FORMAT_UNSIGNED_INT16,
-                  ccuda.CU_AD_FORMAT_SIGNED_INT8,
-                  ccuda.CU_AD_FORMAT_UNSIGNED_INT8,
-                  ccuda.CU_AD_FORMAT_NV12,
-                  ccuda.CU_AD_FORMAT_SNORM_INT8X1,
-                  ccuda.CU_AD_FORMAT_UNORM_INT8X1,
-                  ccuda.CU_AD_FORMAT_SNORM_INT8X2,
-                  ccuda.CU_AD_FORMAT_UNORM_INT8X2,
-                  ccuda.CU_AD_FORMAT_SNORM_INT16X1,
-                  ccuda.CU_AD_FORMAT_UNORM_INT16X1,
-                  ccuda.CU_AD_FORMAT_SNORM_INT8X4,
-                  ccuda.CU_AD_FORMAT_UNORM_INT8X4,
-                  ccuda.CU_AD_FORMAT_SNORM_INT16X2,
-                  ccuda.CU_AD_FORMAT_UNORM_INT16X2,
-                  ccuda.CU_AD_FORMAT_SNORM_INT16X4,
-                  ccuda.CU_AD_FORMAT_UNORM_INT16X4):
+cdef cudaError_t getArrayBlockExtent(cudaExtent *blockExtent, cydriver.CUarray_format format) except ?cudaErrorCallRequiresNewerDriver nogil:
+    if format in (cydriver.CU_AD_FORMAT_FLOAT,
+                  cydriver.CU_AD_FORMAT_UNSIGNED_INT32,
+                  cydriver.CU_AD_FORMAT_SIGNED_INT32,
+                  cydriver.CU_AD_FORMAT_HALF,
+                  cydriver.CU_AD_FORMAT_SIGNED_INT16,
+                  cydriver.CU_AD_FORMAT_UNSIGNED_INT16,
+                  cydriver.CU_AD_FORMAT_SIGNED_INT8,
+                  cydriver.CU_AD_FORMAT_UNSIGNED_INT8,
+                  cydriver.CU_AD_FORMAT_NV12,
+                  cydriver.CU_AD_FORMAT_SNORM_INT8X1,
+                  cydriver.CU_AD_FORMAT_UNORM_INT8X1,
+                  cydriver.CU_AD_FORMAT_SNORM_INT8X2,
+                  cydriver.CU_AD_FORMAT_UNORM_INT8X2,
+                  cydriver.CU_AD_FORMAT_SNORM_INT16X1,
+                  cydriver.CU_AD_FORMAT_UNORM_INT16X1,
+                  cydriver.CU_AD_FORMAT_SNORM_INT8X4,
+                  cydriver.CU_AD_FORMAT_UNORM_INT8X4,
+                  cydriver.CU_AD_FORMAT_SNORM_INT16X2,
+                  cydriver.CU_AD_FORMAT_UNORM_INT16X2,
+                  cydriver.CU_AD_FORMAT_SNORM_INT16X4,
+                  cydriver.CU_AD_FORMAT_UNORM_INT16X4):
         blockExtent[0].width = 1
         blockExtent[0].height = 1
         blockExtent[0].depth = 1
-    elif format in (ccuda.CU_AD_FORMAT_BC1_UNORM,
-                    ccuda.CU_AD_FORMAT_BC1_UNORM_SRGB,
-                    ccuda.CU_AD_FORMAT_BC4_UNORM,
-                    ccuda.CU_AD_FORMAT_BC4_SNORM,
-                    ccuda.CU_AD_FORMAT_BC2_UNORM,
-                    ccuda.CU_AD_FORMAT_BC2_UNORM_SRGB,
-                    ccuda.CU_AD_FORMAT_BC3_UNORM,
-                    ccuda.CU_AD_FORMAT_BC3_UNORM_SRGB,
-                    ccuda.CU_AD_FORMAT_BC5_UNORM,
-                    ccuda.CU_AD_FORMAT_BC5_SNORM,
-                    ccuda.CU_AD_FORMAT_BC6H_UF16,
-                    ccuda.CU_AD_FORMAT_BC6H_SF16,
-                    ccuda.CU_AD_FORMAT_BC7_UNORM,
-                    ccuda.CU_AD_FORMAT_BC7_UNORM_SRGB):
+    elif format in (cydriver.CU_AD_FORMAT_BC1_UNORM,
+                    cydriver.CU_AD_FORMAT_BC1_UNORM_SRGB,
+                    cydriver.CU_AD_FORMAT_BC4_UNORM,
+                    cydriver.CU_AD_FORMAT_BC4_SNORM,
+                    cydriver.CU_AD_FORMAT_BC2_UNORM,
+                    cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB,
+                    cydriver.CU_AD_FORMAT_BC3_UNORM,
+                    cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB,
+                    cydriver.CU_AD_FORMAT_BC5_UNORM,
+                    cydriver.CU_AD_FORMAT_BC5_SNORM,
+                    cydriver.CU_AD_FORMAT_BC6H_UF16,
+                    cydriver.CU_AD_FORMAT_BC6H_SF16,
+                    cydriver.CU_AD_FORMAT_BC7_UNORM,
+                    cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB):
         blockExtent[0].width = 4
         blockExtent[0].height = 4
         blockExtent[0].depth = 1
@@ -1155,15 +1155,16 @@ cdef cudaError_t getArrayBlockExtent(cudaExtent *blockExtent, ccuda.CUarray_form
 
 cdef cudaError_t getLocalState(cudaArrayLocalState *state, cudaArray_const_t thisArray) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaExtent compBlockExtent
+    memset(&arrayState, 0, sizeof(arrayState))
+    arrayState.array = <cydriver.CUarray>thisArray
 
-    arrayState.array = <ccuda.CUarray>thisArray
+    cdef cudaExtent compBlockExtent
     compBlockExtent.width = 1
     compBlockExtent.height = 1
     compBlockExtent.depth = 1
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 driverDesc
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 driverDesc
     memset(&driverDesc, 0, sizeof(driverDesc))
-    err = <cudaError_t>ccuda._cuArray3DGetDescriptor_v2(&driverDesc, <ccuda.CUarray>arrayState.array)
+    err = <cudaError_t>cydriver._cuArray3DGetDescriptor_v2(&driverDesc, <cydriver.CUarray>arrayState.array)
     if err != cudaSuccess:
         return err
     err = getChannelFormatDescFromDriverDesc(&arrayState.desc, &arrayState.depth, &arrayState.height, &arrayState.width, &driverDesc)
@@ -1181,14 +1182,14 @@ cdef cudaError_t getLocalState(cudaArrayLocalState *state, cudaArray_const_t thi
     return cudaSuccess
 
 
-cdef cudaError_t copyFromHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t spitch, size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
+cdef cudaError_t copyFromHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t spitch, size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
     cdef cudaArrayLocalState arrayState
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
 
     cp.dstArray      = arrayState.array
     cp.dstXInBytes   = wOffset
@@ -1206,21 +1207,21 @@ cdef cudaError_t copyFromHost2D(cudaArray_const_t thisArray, size_t hOffset, siz
     return err
 
 
-cdef cudaError_t copyFromDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset,
-        size_t spitch, size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
+cdef cudaError_t copyFromDevice2D(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset,
+        size_t spitch, size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+    cdef cudaError_t err = cudaSuccess
     cdef cudaArrayLocalState arrayState
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, type)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, type)
 
     cp.dstArray      = arrayState.array
     cp.dstXInBytes   = wOffset
     cp.dstY          = hOffset
 
-    cp.srcDevice     = <ccuda.CUdeviceptr_v2>src
+    cp.srcDevice     = <cydriver.CUdeviceptr_v2>src
     cp.srcPitch      = spitch
     cp.srcXInBytes   = srcOffset % spitch
     cp.srcY          = <size_t>(srcOffset / spitch)
@@ -1236,14 +1237,14 @@ cdef cudaError_t copyFromDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thi
 
 
 cdef cudaError_t copyToHost2D(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t dpitch, size_t width,
-        size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+        size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
 
     cp.dstHost       = dst
     cp.dstPitch      = dpitch
@@ -1264,18 +1265,18 @@ cdef cudaError_t copyToHost2D(cudaArray_const_t thisArray, size_t hOffset, size_
     return cudaSuccess
 
 
-cdef cudaError_t copyToDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t dpitch,
-        size_t width, size_t height, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t copyToDevice2D(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t dpitch,
+        size_t width, size_t height, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
 
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(type, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(type, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
 
-    cp.dstDevice     = <ccuda.CUdeviceptr_v2>dst
+    cp.dstDevice     = <cydriver.CUdeviceptr_v2>dst
     cp.dstPitch      = dpitch
     cp.dstXInBytes   = dstOffset % dpitch
     cp.dstY          = <size_t>(dstOffset / dpitch)
@@ -1297,14 +1298,14 @@ cdef cudaError_t copyToDevice2D(ccuda.CUmemorytype type, cudaArray_const_t thisA
 cdef cudaError_t copyToArray2D(cudaArray_const_t thisArray, size_t hOffsetSrc, size_t wOffsetSrc, cudaArray_t dst,
         size_t hOffsetDst, size_t wOffsetDst, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
 
-    cp.dstArray      = <ccuda.CUarray>dst
+    cp.dstArray      = <cydriver.CUarray>dst
     cp.dstXInBytes   = wOffsetDst
     cp.dstY          = hOffsetDst
 
@@ -1325,7 +1326,7 @@ cdef cudaError_t copyToArray2D(cudaArray_const_t thisArray, size_t hOffsetSrc, s
 cdef cudaError_t copyToArray(cudaArray_const_t thisArray, size_t hOffsetSrc, size_t wOffsetSrc, cudaArray_t dst, size_t hOffsetDst,
         size_t wOffsetDst, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef void *tmp
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     err = cudaMalloc(&tmp, count)
     if err != cudaSuccess:
         return err
@@ -1354,7 +1355,7 @@ cdef cudaError_t memcpyArrayToArray(cudaArray_t dst, size_t hOffsetDst, size_t w
 
 cdef cudaError_t getChannelDesc(cudaArray_const_t thisArray, cudaChannelFormatDesc *outDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)  
     if err != cudaSuccess:
@@ -1363,59 +1364,59 @@ cdef cudaError_t getChannelDesc(cudaArray_const_t thisArray, cudaChannelFormatDe
     return cudaSuccess
 
 
-cdef cudaError_t getFormat(cudaArray_const_t thisArray, int &numberOfChannels, ccuda.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t getFormat(cudaArray_const_t thisArray, int &numberOfChannels, cydriver.CUarray_format *format) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
-    return getDescInfo(&arrayState.desc, <int*>&numberOfChannels, <ccuda.CUarray_format*>format)
+    return getDescInfo(&arrayState.desc, <int*>&numberOfChannels, <cydriver.CUarray_format*>format)
 
 
-cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, const cudaResourceDesc *rdSrc,
-                                             ccuda.CUDA_TEXTURE_DESC *tdDst, const cudaTextureDesc_v2 *tdSrc,
-                                             ccuda.CUDA_RESOURCE_VIEW_DESC *rvdDst, const cudaResourceViewDesc *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t getDriverResDescFromResDesc(cydriver.CUDA_RESOURCE_DESC *rdDst, const cudaResourceDesc *rdSrc,
+                                             cydriver.CUDA_TEXTURE_DESC *tdDst, const cudaTextureDesc_v2 *tdSrc,
+                                             cydriver.CUDA_RESOURCE_VIEW_DESC *rvdDst, const cudaResourceViewDesc *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef int i = 0
     cdef int numChannels = 0
-    cdef ccuda.CUarray_format format
-    cdef ccuda.CUarray hArray = NULL
-    cdef cudaError_t err
+    cdef cydriver.CUarray_format format
+    cdef cydriver.CUarray hArray = NULL
+    cdef cudaError_t err = cudaSuccess
     i = 0
 
     memset(rdDst, 0, sizeof(rdDst[0]))
 
     if rdSrc[0].resType == cudaResourceType.cudaResourceTypeArray:
-        rdDst[0].resType          = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY
-        rdDst[0].res.array.hArray = <ccuda.CUarray>rdSrc[0].res.array.array
+        rdDst[0].resType          = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY
+        rdDst[0].res.array.hArray = <cydriver.CUarray>rdSrc[0].res.array.array
         err = getFormat(rdSrc[0].res.array.array, numChannels, &format)
         if err != cudaSuccess:
             return err
     elif rdSrc[0].resType == cudaResourceType.cudaResourceTypeMipmappedArray:
-        rdDst[0].resType                    = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
-        rdDst[0].res.mipmap.hMipmappedArray = <ccuda.CUmipmappedArray>rdSrc[0].res.mipmap.mipmap
-        err = <cudaError_t>ccuda._cuMipmappedArrayGetLevel(&hArray, rdDst[0].res.mipmap.hMipmappedArray, 0)
+        rdDst[0].resType                    = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
+        rdDst[0].res.mipmap.hMipmappedArray = <cydriver.CUmipmappedArray>rdSrc[0].res.mipmap.mipmap
+        err = <cudaError_t>cydriver._cuMipmappedArrayGetLevel(&hArray, rdDst[0].res.mipmap.hMipmappedArray, 0)
         if err != cudaSuccess:
             return err
         err = getFormat(<cudaArray_t>hArray, numChannels, &format)
         if err != cudaSuccess:
             return err
     elif rdSrc[0].resType == cudaResourceType.cudaResourceTypeLinear:
-        rdDst[0].resType                = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR
-        rdDst[0].res.linear.devPtr      = <ccuda.CUdeviceptr_v2>rdSrc[0].res.linear.devPtr
+        rdDst[0].resType                = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR
+        rdDst[0].res.linear.devPtr      = <cydriver.CUdeviceptr_v2>rdSrc[0].res.linear.devPtr
         rdDst[0].res.linear.sizeInBytes = rdSrc[0].res.linear.sizeInBytes
-        err = getDescInfo(&rdSrc[0].res.linear.desc, <int*>&numChannels, <ccuda.CUarray_format*>&format)
+        err = getDescInfo(&rdSrc[0].res.linear.desc, <int*>&numChannels, <cydriver.CUarray_format*>&format)
         if err != cudaSuccess:
             return err
         rdDst[0].res.linear.format      = format
         rdDst[0].res.linear.numChannels = numChannels
     elif rdSrc[0].resType == cudaResourceType.cudaResourceTypePitch2D:
-        rdDst[0].resType                  = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D
-        rdDst[0].res.pitch2D.devPtr       = <ccuda.CUdeviceptr_v2>rdSrc[0].res.pitch2D.devPtr
+        rdDst[0].resType                  = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D
+        rdDst[0].res.pitch2D.devPtr       = <cydriver.CUdeviceptr_v2>rdSrc[0].res.pitch2D.devPtr
         rdDst[0].res.pitch2D.pitchInBytes = rdSrc[0].res.pitch2D.pitchInBytes
         rdDst[0].res.pitch2D.width        = rdSrc[0].res.pitch2D.width
         rdDst[0].res.pitch2D.height       = rdSrc[0].res.pitch2D.height
-        err = getDescInfo(&rdSrc[0].res.linear.desc, <int*>&numChannels, <ccuda.CUarray_format*>&format)
+        err = getDescInfo(&rdSrc[0].res.linear.desc, <int*>&numChannels, <cydriver.CUarray_format*>&format)
         if err != cudaSuccess:
             return err
         rdDst[0].res.pitch2D.format       = format
@@ -1430,11 +1431,11 @@ cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, co
         memset(tdDst, 0, sizeof(tdDst[0]))
 
         while (i < 3):
-            tdDst[0].addressMode[i] = <ccuda.CUaddress_mode>tdSrc[0].addressMode[i]
+            tdDst[0].addressMode[i] = <cydriver.CUaddress_mode>tdSrc[0].addressMode[i]
             i += 1
 
-        tdDst[0].filterMode          = <ccuda.CUfilter_mode>tdSrc[0].filterMode
-        tdDst[0].mipmapFilterMode    = <ccuda.CUfilter_mode>tdSrc[0].mipmapFilterMode
+        tdDst[0].filterMode          = <cydriver.CUfilter_mode>tdSrc[0].filterMode
+        tdDst[0].mipmapFilterMode    = <cydriver.CUfilter_mode>tdSrc[0].mipmapFilterMode
         tdDst[0].mipmapLevelBias     = tdSrc[0].mipmapLevelBias
         tdDst[0].minMipmapLevelClamp = tdSrc[0].minMipmapLevelClamp
         tdDst[0].maxMipmapLevelClamp = tdSrc[0].maxMipmapLevelClamp
@@ -1445,62 +1446,62 @@ cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, co
             i += 1
 
         if tdSrc[0].sRGB:
-            tdDst[0].flags |= ccuda.CU_TRSF_SRGB
+            tdDst[0].flags |= cydriver.CU_TRSF_SRGB
         else:
             tdDst[0].flags |= 0
 
         if tdSrc[0].normalizedCoords:
-            tdDst[0].flags |= ccuda.CU_TRSF_NORMALIZED_COORDINATES
+            tdDst[0].flags |= cydriver.CU_TRSF_NORMALIZED_COORDINATES
         else:
             tdDst[0].flags |= 0
 
         if tdSrc[0].disableTrilinearOptimization:
-            tdDst[0].flags |= ccuda.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
+            tdDst[0].flags |= cydriver.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
         else:
             tdDst[0].flags |= 0
 
         if tdSrc[0].seamlessCubemap:
-            tdDst[0].flags |= ccuda.CU_TRSF_SEAMLESS_CUBEMAP
+            tdDst[0].flags |= cydriver.CU_TRSF_SEAMLESS_CUBEMAP
         else:
             tdDst[0].flags |= 0
 
-        if format in (ccuda.CU_AD_FORMAT_SNORM_INT8X1,
-                      ccuda.CU_AD_FORMAT_SNORM_INT8X2,
-                      ccuda.CU_AD_FORMAT_SNORM_INT8X4,
-                      ccuda.CU_AD_FORMAT_UNORM_INT8X1,
-                      ccuda.CU_AD_FORMAT_UNORM_INT8X2,
-                      ccuda.CU_AD_FORMAT_UNORM_INT8X4,
-                      ccuda.CU_AD_FORMAT_SNORM_INT16X1,
-                      ccuda.CU_AD_FORMAT_SNORM_INT16X2,
-                      ccuda.CU_AD_FORMAT_SNORM_INT16X4,
-                      ccuda.CU_AD_FORMAT_UNORM_INT16X1,
-                      ccuda.CU_AD_FORMAT_UNORM_INT16X2,
-                      ccuda.CU_AD_FORMAT_UNORM_INT16X4,
-                      ccuda.CU_AD_FORMAT_BC1_UNORM,
-                      ccuda.CU_AD_FORMAT_BC1_UNORM_SRGB,
-                      ccuda.CU_AD_FORMAT_BC2_UNORM,
-                      ccuda.CU_AD_FORMAT_BC2_UNORM_SRGB,
-                      ccuda.CU_AD_FORMAT_BC3_UNORM,
-                      ccuda.CU_AD_FORMAT_BC3_UNORM_SRGB,
-                      ccuda.CU_AD_FORMAT_BC4_UNORM,
-                      ccuda.CU_AD_FORMAT_BC4_SNORM,
-                      ccuda.CU_AD_FORMAT_BC5_UNORM,
-                      ccuda.CU_AD_FORMAT_BC5_SNORM,
-                      ccuda.CU_AD_FORMAT_BC7_UNORM,
-                      ccuda.CU_AD_FORMAT_BC7_UNORM_SRGB):
+        if format in (cydriver.CU_AD_FORMAT_SNORM_INT8X1,
+                      cydriver.CU_AD_FORMAT_SNORM_INT8X2,
+                      cydriver.CU_AD_FORMAT_SNORM_INT8X4,
+                      cydriver.CU_AD_FORMAT_UNORM_INT8X1,
+                      cydriver.CU_AD_FORMAT_UNORM_INT8X2,
+                      cydriver.CU_AD_FORMAT_UNORM_INT8X4,
+                      cydriver.CU_AD_FORMAT_SNORM_INT16X1,
+                      cydriver.CU_AD_FORMAT_SNORM_INT16X2,
+                      cydriver.CU_AD_FORMAT_SNORM_INT16X4,
+                      cydriver.CU_AD_FORMAT_UNORM_INT16X1,
+                      cydriver.CU_AD_FORMAT_UNORM_INT16X2,
+                      cydriver.CU_AD_FORMAT_UNORM_INT16X4,
+                      cydriver.CU_AD_FORMAT_BC1_UNORM,
+                      cydriver.CU_AD_FORMAT_BC1_UNORM_SRGB,
+                      cydriver.CU_AD_FORMAT_BC2_UNORM,
+                      cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB,
+                      cydriver.CU_AD_FORMAT_BC3_UNORM,
+                      cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB,
+                      cydriver.CU_AD_FORMAT_BC4_UNORM,
+                      cydriver.CU_AD_FORMAT_BC4_SNORM,
+                      cydriver.CU_AD_FORMAT_BC5_UNORM,
+                      cydriver.CU_AD_FORMAT_BC5_SNORM,
+                      cydriver.CU_AD_FORMAT_BC7_UNORM,
+                      cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB):
             if tdSrc[0].readMode != cudaTextureReadMode.cudaReadModeNormalizedFloat:
                 return cudaErrorInvalidNormSetting
-        elif format in (ccuda.CU_AD_FORMAT_SIGNED_INT8,
-                        ccuda.CU_AD_FORMAT_SIGNED_INT16,
-                        ccuda.CU_AD_FORMAT_UNSIGNED_INT8,
-                        ccuda.CU_AD_FORMAT_UNSIGNED_INT16):
+        elif format in (cydriver.CU_AD_FORMAT_SIGNED_INT8,
+                        cydriver.CU_AD_FORMAT_SIGNED_INT16,
+                        cydriver.CU_AD_FORMAT_UNSIGNED_INT8,
+                        cydriver.CU_AD_FORMAT_UNSIGNED_INT16):
             if tdSrc[0].readMode == cudaReadModeElementType:
                 if tdSrc[0].filterMode == cudaTextureFilterMode.cudaFilterModeLinear:
                     return cudaErrorInvalidFilterSetting
-                tdDst[0].flags |= ccuda.CU_TRSF_READ_AS_INTEGER
-        elif format == ccuda.CU_AD_FORMAT_NV12:
+                tdDst[0].flags |= cydriver.CU_TRSF_READ_AS_INTEGER
+        elif format == cydriver.CU_AD_FORMAT_NV12:
             return cudaErrorInvalidValue
-        elif format == ccuda.CU_AD_FORMAT_SIGNED_INT32 or format == ccuda.CU_AD_FORMAT_UNSIGNED_INT32:
+        elif format == cydriver.CU_AD_FORMAT_SIGNED_INT32 or format == cydriver.CU_AD_FORMAT_UNSIGNED_INT32:
             if tdSrc[0].filterMode == cudaTextureFilterMode.cudaFilterModeLinear:
                 return cudaErrorInvalidFilterSetting
             if tdSrc[0].readMode == cudaTextureReadMode.cudaReadModeNormalizedFloat:
@@ -1512,7 +1513,7 @@ cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, co
     if rvdDst and rvdSrc:
         memset(rvdDst, 0, sizeof(rvdDst[0]))
 
-        rvdDst[0].format           = <ccuda.CUresourceViewFormat>rvdSrc[0].format
+        rvdDst[0].format           = <cydriver.CUresourceViewFormat>rvdSrc[0].format
         rvdDst[0].width            = rvdSrc[0].width
         rvdDst[0].height           = rvdSrc[0].height
         rvdDst[0].depth            = rvdSrc[0].depth
@@ -1524,32 +1525,34 @@ cdef cudaError_t getDriverResDescFromResDesc(ccuda.CUDA_RESOURCE_DESC *rdDst, co
     return cudaSuccess
 
 
-cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const ccuda.CUDA_RESOURCE_DESC *rdSrc,
-                                             cudaTextureDesc_v2 *tdDst, const ccuda.CUDA_TEXTURE_DESC *tdSrc,
-                                             cudaResourceViewDesc *rvdDst, const ccuda.CUDA_RESOURCE_VIEW_DESC *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const cydriver.CUDA_RESOURCE_DESC *rdSrc,
+                                             cudaTextureDesc_v2 *tdDst, const cydriver.CUDA_TEXTURE_DESC *tdSrc,
+                                             cudaResourceViewDesc *rvdDst, const cydriver.CUDA_RESOURCE_VIEW_DESC *rvdSrc) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef int i = 0
     cdef int numChannels = 0
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
-    cdef ccuda.CUarray hArray
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
+    cdef cydriver.CUarray hArray
 
     memset(rdDst, 0, sizeof(rdDst[0]))
+    memset(&ad, 0, sizeof(ad))
+    memset(&hArray, 0, sizeof(hArray))
 
-    if rdSrc[0].resType == ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY:
+    if rdSrc[0].resType == cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY:
         rdDst[0].resType         = cudaResourceType.cudaResourceTypeArray
         rdDst[0].res.array.array = <cudaArray_t>rdSrc[0].res.array.hArray
         err = getFormat(rdDst[0].res.array.array, numChannels, &ad.Format)
         if err != cudaSuccess:
             return err
-    elif rdSrc[0].resType == ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY:
+    elif rdSrc[0].resType == cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY:
         rdDst[0].resType = cudaResourceType.cudaResourceTypeMipmappedArray
         rdDst[0].res.mipmap.mipmap = <cudaMipmappedArray_t>rdSrc[0].res.mipmap.hMipmappedArray
-        err = <cudaError_t>ccuda._cuMipmappedArrayGetLevel(&hArray, rdSrc[0].res.mipmap.hMipmappedArray, 0)
+        err = <cudaError_t>cydriver._cuMipmappedArrayGetLevel(&hArray, rdSrc[0].res.mipmap.hMipmappedArray, 0)
         if err != cudaSuccess:
             return err
         err = getFormat(<cudaArray_t>hArray, numChannels, &ad.Format)
         if err != cudaSuccess:
             return err
-    elif rdSrc[0].resType == ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR:
+    elif rdSrc[0].resType == cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR:
         rdDst[0].resType                = cudaResourceType.cudaResourceTypeLinear
         rdDst[0].res.linear.devPtr      = <void *>rdSrc[0].res.linear.devPtr
         rdDst[0].res.linear.sizeInBytes = rdSrc[0].res.linear.sizeInBytes
@@ -1560,7 +1563,7 @@ cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const ccud
                                                  &ad)
         if err != cudaSuccess:
             return err
-    elif rdSrc[0].resType == ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D:
+    elif rdSrc[0].resType == cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D:
         rdDst[0].resType                  = cudaResourceType.cudaResourceTypePitch2D
         rdDst[0].res.pitch2D.devPtr       = <void *>rdSrc[0].res.pitch2D.devPtr
         rdDst[0].res.pitch2D.pitchInBytes = rdSrc[0].res.pitch2D.pitchInBytes
@@ -1594,57 +1597,57 @@ cdef cudaError_t getResDescFromDriverResDesc(cudaResourceDesc *rdDst, const ccud
             tdDst[0].borderColor[i] = tdSrc[0].borderColor[i]
             i += 1
 
-        if tdSrc[0].flags & ccuda.CU_TRSF_SRGB:
+        if tdSrc[0].flags & cydriver.CU_TRSF_SRGB:
             tdDst[0].sRGB                         = 1
         else:
             tdDst[0].sRGB                         = 0
 
-        if tdSrc[0].flags & ccuda.CU_TRSF_NORMALIZED_COORDINATES:
+        if tdSrc[0].flags & cydriver.CU_TRSF_NORMALIZED_COORDINATES:
             tdDst[0].normalizedCoords             = 1
         else:
             tdDst[0].normalizedCoords             = 0
 
-        if tdSrc[0].flags & ccuda.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION:
+        if tdSrc[0].flags & cydriver.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION:
             tdDst[0].disableTrilinearOptimization = 1
         else:
             tdDst[0].disableTrilinearOptimization = 0
 
-        if tdSrc[0].flags & ccuda.CU_TRSF_SEAMLESS_CUBEMAP:
+        if tdSrc[0].flags & cydriver.CU_TRSF_SEAMLESS_CUBEMAP:
             tdDst[0].seamlessCubemap |= 1
         else:
             tdDst[0].seamlessCubemap |= 0
 
-        if ad.Format in (ccuda.CU_AD_FORMAT_SNORM_INT8X1,
-                         ccuda.CU_AD_FORMAT_SNORM_INT8X2,
-                         ccuda.CU_AD_FORMAT_SNORM_INT8X4,
-                         ccuda.CU_AD_FORMAT_UNORM_INT8X1,
-                         ccuda.CU_AD_FORMAT_UNORM_INT8X2,
-                         ccuda.CU_AD_FORMAT_UNORM_INT8X4,
-                         ccuda.CU_AD_FORMAT_SNORM_INT16X1,
-                         ccuda.CU_AD_FORMAT_SNORM_INT16X2,
-                         ccuda.CU_AD_FORMAT_SNORM_INT16X4,
-                         ccuda.CU_AD_FORMAT_UNORM_INT16X1,
-                         ccuda.CU_AD_FORMAT_UNORM_INT16X2,
-                         ccuda.CU_AD_FORMAT_UNORM_INT16X4,
-                         ccuda.CU_AD_FORMAT_BC1_UNORM,
-                         ccuda.CU_AD_FORMAT_BC1_UNORM_SRGB,
-                         ccuda.CU_AD_FORMAT_BC2_UNORM,
-                         ccuda.CU_AD_FORMAT_BC2_UNORM_SRGB,
-                         ccuda.CU_AD_FORMAT_BC3_UNORM,
-                         ccuda.CU_AD_FORMAT_BC3_UNORM_SRGB,
-                         ccuda.CU_AD_FORMAT_BC4_UNORM,
-                         ccuda.CU_AD_FORMAT_BC4_SNORM,
-                         ccuda.CU_AD_FORMAT_BC5_UNORM,
-                         ccuda.CU_AD_FORMAT_BC5_SNORM,
-                         ccuda.CU_AD_FORMAT_BC7_UNORM,
-                         ccuda.CU_AD_FORMAT_BC7_UNORM_SRGB):
+        if ad.Format in (cydriver.CU_AD_FORMAT_SNORM_INT8X1,
+                         cydriver.CU_AD_FORMAT_SNORM_INT8X2,
+                         cydriver.CU_AD_FORMAT_SNORM_INT8X4,
+                         cydriver.CU_AD_FORMAT_UNORM_INT8X1,
+                         cydriver.CU_AD_FORMAT_UNORM_INT8X2,
+                         cydriver.CU_AD_FORMAT_UNORM_INT8X4,
+                         cydriver.CU_AD_FORMAT_SNORM_INT16X1,
+                         cydriver.CU_AD_FORMAT_SNORM_INT16X2,
+                         cydriver.CU_AD_FORMAT_SNORM_INT16X4,
+                         cydriver.CU_AD_FORMAT_UNORM_INT16X1,
+                         cydriver.CU_AD_FORMAT_UNORM_INT16X2,
+                         cydriver.CU_AD_FORMAT_UNORM_INT16X4,
+                         cydriver.CU_AD_FORMAT_BC1_UNORM,
+                         cydriver.CU_AD_FORMAT_BC1_UNORM_SRGB,
+                         cydriver.CU_AD_FORMAT_BC2_UNORM,
+                         cydriver.CU_AD_FORMAT_BC2_UNORM_SRGB,
+                         cydriver.CU_AD_FORMAT_BC3_UNORM,
+                         cydriver.CU_AD_FORMAT_BC3_UNORM_SRGB,
+                         cydriver.CU_AD_FORMAT_BC4_UNORM,
+                         cydriver.CU_AD_FORMAT_BC4_SNORM,
+                         cydriver.CU_AD_FORMAT_BC5_UNORM,
+                         cydriver.CU_AD_FORMAT_BC5_SNORM,
+                         cydriver.CU_AD_FORMAT_BC7_UNORM,
+                         cydriver.CU_AD_FORMAT_BC7_UNORM_SRGB):
             tdDst[0].readMode = cudaTextureReadMode.cudaReadModeNormalizedFloat
-        elif ad.Format in (ccuda.CU_AD_FORMAT_SIGNED_INT8,
-                           ccuda.CU_AD_FORMAT_SIGNED_INT16,
-                           ccuda.CU_AD_FORMAT_UNSIGNED_INT8,
-                           ccuda.CU_AD_FORMAT_UNSIGNED_INT16):
+        elif ad.Format in (cydriver.CU_AD_FORMAT_SIGNED_INT8,
+                           cydriver.CU_AD_FORMAT_SIGNED_INT16,
+                           cydriver.CU_AD_FORMAT_UNSIGNED_INT8,
+                           cydriver.CU_AD_FORMAT_UNSIGNED_INT16):
             with gil:
-                if (tdSrc[0].flags & ccuda.CU_TRSF_READ_AS_INTEGER):
+                if (tdSrc[0].flags & cydriver.CU_TRSF_READ_AS_INTEGER):
                     tdDst[0].readMode = cudaTextureReadMode.cudaReadModeElementType
                 else:
                     tdDst[0].readMode = cudaTextureReadMode.cudaReadModeNormalizedFloat
@@ -1671,9 +1674,9 @@ cdef cudaError_t memsetPtr(char *mem, int c, size_t count, cudaStream_t sid, boo
         return cudaSuccess
 
     if not async:
-        return <cudaError_t>ccuda._cuMemsetD8_v2(<ccuda.CUdeviceptr_v2>mem, <unsigned char>c, count)
+        return <cudaError_t>cydriver._cuMemsetD8_v2(<cydriver.CUdeviceptr_v2>mem, <unsigned char>c, count)
     else:
-        return <cudaError_t>ccuda._cuMemsetD8Async(<ccuda.CUdeviceptr_v2>mem, <unsigned char>c, count, sid)
+        return <cudaError_t>cydriver._cuMemsetD8Async(<cydriver.CUdeviceptr_v2>mem, <unsigned char>c, count, sid)
 
 
 cdef cudaError_t memset2DPtr(char *mem, size_t pitch, int c, size_t width, size_t height, cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
@@ -1681,20 +1684,20 @@ cdef cudaError_t memset2DPtr(char *mem, size_t pitch, int c, size_t width, size_
         return cudaSuccess
 
     if not async:
-        return <cudaError_t>ccuda._cuMemsetD2D8_v2(<ccuda.CUdeviceptr_v2>mem, pitch, <unsigned char>c, width, height)
+        return <cudaError_t>cydriver._cuMemsetD2D8_v2(<cydriver.CUdeviceptr_v2>mem, pitch, <unsigned char>c, width, height)
     else:
-        return <cudaError_t>ccuda._cuMemsetD2D8Async(<ccuda.CUdeviceptr_v2>mem, pitch, <unsigned char>c, width, height, sid)
+        return <cudaError_t>cydriver._cuMemsetD2D8Async(<cydriver.CUdeviceptr_v2>mem, pitch, <unsigned char>c, width, height, sid)
 
 
-cdef cudaError_t copyFromHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t copyFromHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
     cdef size_t copied = 0
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
 
     if (wOffset > 0) and (count >= arrayState.widthInBytes - wOffset):
         cp.dstArray      = arrayState.array
@@ -1758,22 +1761,22 @@ cdef cudaError_t copyFromHost(cudaArray_const_t thisArray, size_t hOffset, size_
     return cudaSuccess
 
 
-cdef cudaError_t copyFromDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t copyFromDevice(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *src, size_t srcOffset, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
     cdef size_t copied = 0
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, type)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY, type)
 
     if (wOffset > 0) and (count >= arrayState.widthInBytes - wOffset):
         cp.dstArray      = arrayState.array
         cp.dstXInBytes   = wOffset
         cp.dstY          = hOffset
 
-        cp.srcDevice     = <ccuda.CUdeviceptr_v2>src
+        cp.srcDevice     = <cydriver.CUdeviceptr_v2>src
         cp.srcPitch      = arrayState.widthInBytes
         cp.srcXInBytes   = srcOffset
         cp.srcY          = 0
@@ -1794,7 +1797,7 @@ cdef cudaError_t copyFromDevice(ccuda.CUmemorytype type, cudaArray_const_t thisA
         cp.dstXInBytes   = wOffset
         cp.dstY          = hOffset
 
-        cp.srcDevice     = <ccuda.CUdeviceptr_v2>(src + copied)
+        cp.srcDevice     = <cydriver.CUdeviceptr_v2>(src + copied)
         cp.srcPitch      = arrayState.widthInBytes
         cp.srcXInBytes   = srcOffset
         cp.srcY          = 0
@@ -1816,7 +1819,7 @@ cdef cudaError_t copyFromDevice(ccuda.CUmemorytype type, cudaArray_const_t thisA
         cp.dstXInBytes   = wOffset
         cp.dstY          = hOffset
 
-        cp.srcDevice     = <ccuda.CUdeviceptr_v2>(src + copied)
+        cp.srcDevice     = <cydriver.CUdeviceptr_v2>(src + copied)
         cp.srcPitch      = arrayState.widthInBytes
         cp.srcXInBytes   = srcOffset
         cp.srcY          = 0
@@ -1831,15 +1834,15 @@ cdef cudaError_t copyFromDevice(ccuda.CUmemorytype type, cudaArray_const_t thisA
     return cudaSuccess
 
 
-cdef cudaError_t copyToHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t copyToHost(cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, char *dst, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
     cdef size_t copied = 0
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
 
     if (wOffset > 0) and (count >= arrayState.widthInBytes - wOffset):
         cp.dstHost       = dst
@@ -1903,26 +1906,28 @@ cdef cudaError_t copyToHost(cudaArray_const_t thisArray, size_t hOffset, size_t
     return cudaSuccess
 
 
-cdef cudaError_t driverMemcpy3DPeer(ccuda.CUDA_MEMCPY3D_PEER *cp, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t driverMemcpy3DPeer(cydriver.CUDA_MEMCPY3D_PEER *cp, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     if async:
-        return <cudaError_t>ccuda._cuMemcpy3DPeerAsync(cp, stream)
+        return <cudaError_t>cydriver._cuMemcpy3DPeerAsync(cp, stream)
     else:
-        return <cudaError_t>ccuda._cuMemcpy3DPeer(cp)
+        return <cudaError_t>cydriver._cuMemcpy3DPeer(cp)
 
 
-cdef cudaError_t driverMemcpy3D(ccuda.CUDA_MEMCPY3D_v2 *cp, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t driverMemcpy3D(cydriver.CUDA_MEMCPY3D_v2 *cp, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     if async:
-        return <cudaError_t>ccuda._cuMemcpy3DAsync_v2(cp, stream)
+        return <cudaError_t>cydriver._cuMemcpy3DAsync_v2(cp, stream)
     else:
-        return <cudaError_t>ccuda._cuMemcpy3D_v2(cp)
+        return <cudaError_t>cydriver._cuMemcpy3D_v2(cp)
 
 
 cdef cudaError_t memcpy3D(const cudaMemcpy3DParms *p, bool peer, int srcDevice, int dstDevice, cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUDA_MEMCPY3D_v2 cd
-    cdef ccuda.CUDA_MEMCPY3D_PEER cdPeer
+    cdef cydriver.CUDA_MEMCPY3D_v2 cd
+    cdef cydriver.CUDA_MEMCPY3D_PEER cdPeer
     cdef cudaPythonDevice *srcDev
     cdef cudaPythonDevice *dstDev
 
+    memset(&cdPeer, 0, sizeof(cdPeer))
+
     cdef cudaError_t err = toDriverMemCopy3DParams(p, &cd)
     if err != cudaSuccess:
         return err
@@ -1964,18 +1969,18 @@ cdef cudaError_t memcpy3D(const cudaMemcpy3DParms *p, bool peer, int srcDevice,
     return err
 
 
-cdef cudaError_t copyToDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t count, ccuda.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t copyToDevice(cydriver.CUmemorytype type, cudaArray_const_t thisArray, size_t hOffset, size_t wOffset, const char *dst, size_t dstOffset, size_t count, cydriver.CUstream stream, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaArrayLocalState arrayState
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     memset(&arrayState, 0, sizeof(arrayState))
     err = getLocalState(&arrayState, thisArray)
     if err != cudaSuccess:
         return err
     cdef size_t copied = 0
-    cdef ccuda.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(type, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+    cdef cydriver.CUDA_MEMCPY3D_v2 cp = memCopy3DInit(type, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
 
     if (wOffset > 0) and (count >= arrayState.widthInBytes - wOffset):
-        cp.dstDevice     = <ccuda.CUdeviceptr_v2>dst
+        cp.dstDevice     = <cydriver.CUdeviceptr_v2>dst
         cp.dstPitch      = arrayState.widthInBytes
         cp.dstXInBytes   = dstOffset
         cp.dstY          = 0
@@ -1996,7 +2001,7 @@ cdef cudaError_t copyToDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArr
             return err
 
     if (count - copied >= arrayState.widthInBytes):
-        cp.dstDevice     = <ccuda.CUdeviceptr_v2>(dst + copied)
+        cp.dstDevice     = <cydriver.CUdeviceptr_v2>(dst + copied)
         cp.dstPitch      = arrayState.widthInBytes
         cp.dstXInBytes   = dstOffset
         cp.dstY          = 0
@@ -2017,7 +2022,7 @@ cdef cudaError_t copyToDevice(ccuda.CUmemorytype type, cudaArray_const_t thisArr
             return err
 
     if (count - copied > 0):
-        cp.dstDevice     = <ccuda.CUdeviceptr_v2>(dst + copied)
+        cp.dstDevice     = <cydriver.CUdeviceptr_v2>(dst + copied)
         cp.dstPitch      = arrayState.widthInBytes
         cp.dstXInBytes   = dstOffset
         cp.dstY          = 0
@@ -2046,8 +2051,8 @@ cdef cudaError_t copy1DConvertTo3DParams(void* dst, const void* src, size_t coun
     p[0].kind = kind
 
 
-cdef void toDriverMemsetNodeParams(const cudaMemsetParams *pRuntimeParams, ccuda.CUDA_MEMSET_NODE_PARAMS *pDriverParams) nogil:
-    pDriverParams[0].dst = <ccuda.CUdeviceptr_v2>pRuntimeParams[0].dst
+cdef void toDriverMemsetNodeParams(const cudaMemsetParams *pRuntimeParams, cydriver.CUDA_MEMSET_NODE_PARAMS *pDriverParams) noexcept nogil:
+    pDriverParams[0].dst = <cydriver.CUdeviceptr_v2>pRuntimeParams[0].dst
     pDriverParams[0].pitch = pRuntimeParams[0].pitch
     pDriverParams[0].value = pRuntimeParams[0].value
     pDriverParams[0].elementSize = pRuntimeParams[0].elementSize
@@ -2056,45 +2061,45 @@ cdef void toDriverMemsetNodeParams(const cudaMemsetParams *pRuntimeParams, ccuda
 
 
 cdef cudaError_t getElementSize(size_t *elementSize, cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR driverDesc
-    cdef cudaError_t err
-    err = <cudaError_t>ccuda._cuArray3DGetDescriptor_v2(&driverDesc, <ccuda.CUarray>array)
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR driverDesc
+    cdef cudaError_t err = cudaSuccess
+    err = <cudaError_t>cydriver._cuArray3DGetDescriptor_v2(&driverDesc, <cydriver.CUarray>array)
     if err != cudaSuccess:
         return err
-    if (driverDesc.Format == ccuda.CU_AD_FORMAT_FLOAT or
-        driverDesc.Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT32 or
-        driverDesc.Format == ccuda.CU_AD_FORMAT_SIGNED_INT32):
+    if (driverDesc.Format == cydriver.CU_AD_FORMAT_FLOAT or
+        driverDesc.Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT32 or
+        driverDesc.Format == cydriver.CU_AD_FORMAT_SIGNED_INT32):
         elementSize[0] = driverDesc.NumChannels * 4
         return cudaSuccess
-    elif (driverDesc.Format == ccuda.CU_AD_FORMAT_HALF or
-          driverDesc.Format == ccuda.CU_AD_FORMAT_SIGNED_INT16 or
-          driverDesc.Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT16):
+    elif (driverDesc.Format == cydriver.CU_AD_FORMAT_HALF or
+          driverDesc.Format == cydriver.CU_AD_FORMAT_SIGNED_INT16 or
+          driverDesc.Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT16):
         elementSize[0] = driverDesc.NumChannels * 2
         return cudaSuccess
-    elif (driverDesc.Format == ccuda.CU_AD_FORMAT_SIGNED_INT8 or
-          driverDesc.Format == ccuda.CU_AD_FORMAT_UNSIGNED_INT8 or
-          driverDesc.Format == ccuda.CU_AD_FORMAT_NV12):
+    elif (driverDesc.Format == cydriver.CU_AD_FORMAT_SIGNED_INT8 or
+          driverDesc.Format == cydriver.CU_AD_FORMAT_UNSIGNED_INT8 or
+          driverDesc.Format == cydriver.CU_AD_FORMAT_NV12):
         elementSize[0] = driverDesc.NumChannels
         return cudaSuccess
     return cudaErrorInvalidChannelDescriptor
 
 
-cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_MEMCPY3D *cd) except ?cudaErrorCallRequiresNewerDriver nogil:
-    memset(cd, 0, sizeof(ccuda.CUDA_MEMCPY3D))
-    cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
-    cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, cydriver.CUDA_MEMCPY3D *cd) except ?cudaErrorCallRequiresNewerDriver nogil:
+    memset(cd, 0, sizeof(cydriver.CUDA_MEMCPY3D))
+    cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+    cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
     cd[0].WidthInBytes = 0
     cd[0].Height = 1
     cd[0].Depth = 1
     cdef size_t srcElementSize = 0
     cdef size_t dstElementSize = 0
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
 
     cdef cudaExtent srcBlockExtent
     cdef cudaExtent dstBlockExtent
     cdef cudaExtent copyBlockExtent
-    cdef ccuda.CUarray_format srcFmt
-    cdef ccuda.CUarray_format dstFmt
+    cdef cydriver.CUarray_format srcFmt
+    cdef cydriver.CUarray_format dstFmt
     cdef int numChannels = 0
     srcBlockExtent.width = srcBlockExtent.height = srcBlockExtent.depth = 1
     dstBlockExtent.width = dstBlockExtent.height = dstBlockExtent.depth = 1
@@ -2104,20 +2109,20 @@ cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_
         return cudaSuccess
 
     if p[0].kind == cudaMemcpyHostToHost:
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST
     elif p[0].kind == cudaMemcpyHostToDevice:
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
     elif p[0].kind == cudaMemcpyDeviceToHost:
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST
     elif p[0].kind == cudaMemcpyDeviceToDevice:
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
     elif p[0].kind == cudaMemcpyDefault:
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED
     else:
         return cudaErrorInvalidMemcpyDirection
 
@@ -2140,10 +2145,10 @@ cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_
             copyBlockExtent = dstBlockExtent
 
     if p[0].srcArray:
-        if NULL != p[0].srcPtr.ptr or ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].srcMemoryType:
+        if NULL != p[0].srcPtr.ptr or cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].srcMemoryType:
             return cudaErrorInvalidValue
-        cd[0].srcMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY
-        cd[0].srcArray = <ccuda.CUarray>p[0].srcArray
+        cd[0].srcMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY
+        cd[0].srcArray = <cydriver.CUarray>p[0].srcArray
         err = getElementSize(&srcElementSize, p[0].srcArray)
         if err != cudaSuccess:
             return err
@@ -2157,18 +2162,18 @@ cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_
             if p[0].extent.height > adjustedSrcHeight:
                 return cudaErrorInvalidPitchValue
 
-        if ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].srcMemoryType:
+        if cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].srcMemoryType:
             cd[0].srcHost = p[0].srcPtr.ptr
         else:
-            cd[0].srcDevice = <ccuda.CUdeviceptr_v2>(p[0].srcPtr.ptr)
+            cd[0].srcDevice = <cydriver.CUdeviceptr_v2>(p[0].srcPtr.ptr)
         cd[0].srcPitch = p[0].srcPtr.pitch
         cd[0].srcHeight = p[0].srcPtr.ysize
 
     if p[0].dstArray:
         if NULL != p[0].dstPtr.ptr:
             return cudaErrorInvalidValue
-        cd[0].dstMemoryType = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY
-        cd[0].dstArray = <ccuda.CUarray>p[0].dstArray
+        cd[0].dstMemoryType = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY
+        cd[0].dstArray = <cydriver.CUarray>p[0].dstArray
         err = getElementSize(&dstElementSize, p[0].dstArray)
         if err != cudaSuccess:
             return err
@@ -2182,10 +2187,10 @@ cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_
             if p[0].extent.height > adjustedDstHeight:
                 return cudaErrorInvalidPitchValue
 
-        if ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].dstMemoryType:
+        if cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST == cd[0].dstMemoryType:
             cd[0].dstHost = p[0].dstPtr.ptr
         else:
-            cd[0].dstDevice = <ccuda.CUdeviceptr_v2>(p[0].dstPtr.ptr)
+            cd[0].dstDevice = <cydriver.CUdeviceptr_v2>(p[0].dstPtr.ptr)
         cd[0].dstPitch = p[0].dstPtr.pitch
         cd[0].dstHeight = p[0].dstPtr.ysize
 
@@ -2202,7 +2207,7 @@ cdef cudaError_t toDriverMemCopy3DParams(const cudaMemcpy3DParms *p, ccuda.CUDA_
 
     # Determine the extent of the transfer
     cd[0].WidthInBytes = <size_t>((p[0].extent.width + copyBlockExtent.width - 1) / copyBlockExtent.width)  * elementSize
-    cd[0].Height       = <size_t>((p[0].extent.height + copyBlockExtent.height - 1) / copyBlockExtent.height);
+    cd[0].Height       = <size_t>((p[0].extent.height + copyBlockExtent.height - 1) / copyBlockExtent.height)
     cd[0].Depth        = p[0].extent.depth
 
     # Populate bloated src copy origin
@@ -2223,9 +2228,9 @@ cdef cudaError_t mallocArray(cudaArray_t *arrayPtr, const cudaChannelFormatDesc
     if arrayPtr == NULL:
         return cudaErrorInvalidValue
 
-    cdef ccuda.CUarray array = NULL
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
-    cdef cudaError_t err
+    cdef cydriver.CUarray array = NULL
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
+    cdef cudaError_t err = cudaSuccess
     arrayPtr[0] = NULL
     if (((width == 0)) or
         ((height == 0) and (depth != 0) and not (flags & cudaArrayLayered)) or
@@ -2235,14 +2240,14 @@ cdef cudaError_t mallocArray(cudaArray_t *arrayPtr, const cudaChannelFormatDesc
         return cudaErrorInvalidValue
     else:
         memset(&ad, 0, sizeof(ad))
-        err = getDescInfo(desc, <int*>&ad.NumChannels, <ccuda.CUarray_format*>&ad.Format)
+        err = getDescInfo(desc, <int*>&ad.NumChannels, <cydriver.CUarray_format*>&ad.Format)
         if err != cudaSuccess:
             return err
         ad.Height = <unsigned int>height
         ad.Width  = <unsigned int>width
         ad.Depth  = <unsigned int>(depth - corr2D)
         ad.Flags  = flags
-        err = <cudaError_t>ccuda._cuArray3DCreate_v2(&array, &ad)
+        err = <cudaError_t>cydriver._cuArray3DCreate_v2(&array, &ad)
         if err != cudaSuccess:
             return err
 
@@ -2258,13 +2263,13 @@ cdef cudaError_t memcpy2DToArray(cudaArray_t dst, size_t hOffset, size_t wOffset
     if height > 1 and width > spitch:
         return cudaErrorInvalidPitchValue
 
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     if kind == cudaMemcpyKind.cudaMemcpyHostToDevice:
        err = copyFromHost2D(dst, hOffset, wOffset, src, spitch, width, height, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-       err = copyFromDevice2D(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, dst, hOffset, wOffset, src, 0, spitch, width, height, sid, async)
+       err = copyFromDevice2D(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, dst, hOffset, wOffset, src, 0, spitch, width, height, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-       err = copyFromDevice2D(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, dst, hOffset, wOffset, src, 0, spitch, width, height, sid, async)
+       err = copyFromDevice2D(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, dst, hOffset, wOffset, src, 0, spitch, width, height, sid, async)
     else:
         return cudaErrorInvalidMemcpyDirection
     return err
@@ -2280,30 +2285,30 @@ cdef cudaError_t memcpy2DPtr(char *dst, size_t dpitch, const char *src, size_t s
     if height > 1 and width > spitch:
         return cudaErrorInvalidPitchValue
 
-    cdef cudaError_t err
-    cdef ccuda.CUDA_MEMCPY2D_v2 cp
+    cdef cudaError_t err = cudaSuccess
+    cdef cydriver.CUDA_MEMCPY2D_v2 cp
     memset(&cp, 0, sizeof(cp))
 
     if kind == cudaMemcpyKind.cudaMemcpyHostToHost:
-        cp = memCopy2DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
+        cp = memCopy2DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
         cp.dstHost = dst
         cp.srcHost = src
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
-        cp = memCopy2DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE)
+        cp = memCopy2DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE)
         cp.dstHost = dst
-        cp.srcDevice = <ccuda.CUdeviceptr_v2>src
+        cp.srcDevice = <cydriver.CUdeviceptr_v2>src
     elif kind == cudaMemcpyKind.cudaMemcpyHostToDevice:
-        cp = memCopy2DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
-        cp.dstDevice = <ccuda.CUdeviceptr_v2>dst
+        cp = memCopy2DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST)
+        cp.dstDevice = <cydriver.CUdeviceptr_v2>dst
         cp.srcHost = src
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        cp = memCopy2DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE)
-        cp.dstDevice = <ccuda.CUdeviceptr_v2>dst
-        cp.srcDevice = <ccuda.CUdeviceptr_v2>src
+        cp = memCopy2DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE)
+        cp.dstDevice = <cydriver.CUdeviceptr_v2>dst
+        cp.srcDevice = <cydriver.CUdeviceptr_v2>src
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        cp = memCopy2DInit(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED)
-        cp.dstDevice = <ccuda.CUdeviceptr_v2>dst
-        cp.srcDevice = <ccuda.CUdeviceptr_v2>src
+        cp = memCopy2DInit(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED)
+        cp.dstDevice = <cydriver.CUdeviceptr_v2>dst
+        cp.srcDevice = <cydriver.CUdeviceptr_v2>src
     else:
         err = cudaErrorInvalidMemcpyDirection
 
@@ -2316,9 +2321,9 @@ cdef cudaError_t memcpy2DPtr(char *dst, size_t dpitch, const char *src, size_t s
     cp.Height        = height
 
     if async:
-        err = <cudaError_t>ccuda._cuMemcpy2DAsync_v2(&cp, sid)
+        err = <cudaError_t>cydriver._cuMemcpy2DAsync_v2(&cp, sid)
     else:
-        err = <cudaError_t>ccuda._cuMemcpy2DUnaligned_v2(&cp)
+        err = <cudaError_t>cydriver._cuMemcpy2DUnaligned_v2(&cp)
     return err
 
 
@@ -2326,17 +2331,17 @@ cdef cudaError_t memcpyDispatch(void *dst, const void *src, size_t size, cudaMem
     if size == 0:
         return cudaSuccess
 
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     if kind == cudaMemcpyKind.cudaMemcpyHostToHost:
         return memcpy2DPtr(<char*>dst, size, <const char*>src, size, size, 1, kind, NULL, 0)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
-        err = <cudaError_t>ccuda._cuMemcpyDtoH_v2(dst, <ccuda.CUdeviceptr_v2>src, size)
+        err = <cudaError_t>cydriver._cuMemcpyDtoH_v2(dst, <cydriver.CUdeviceptr_v2>src, size)
     elif kind == cudaMemcpyKind.cudaMemcpyHostToDevice:
-        err = <cudaError_t>ccuda._cuMemcpyHtoD_v2(<ccuda.CUdeviceptr_v2>dst, src, size)
+        err = <cudaError_t>cydriver._cuMemcpyHtoD_v2(<cydriver.CUdeviceptr_v2>dst, src, size)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        err = <cudaError_t>ccuda._cuMemcpyDtoD_v2(<ccuda.CUdeviceptr_v2>dst, <ccuda.CUdeviceptr_v2>src, size)
+        err = <cudaError_t>cydriver._cuMemcpyDtoD_v2(<cydriver.CUdeviceptr_v2>dst, <cydriver.CUdeviceptr_v2>src, size)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        err = <cudaError_t>ccuda._cuMemcpy(<ccuda.CUdeviceptr_v2>dst, <ccuda.CUdeviceptr_v2>src, size)
+        err = <cudaError_t>cydriver._cuMemcpy(<cydriver.CUdeviceptr_v2>dst, <cydriver.CUdeviceptr_v2>src, size)
     else:
         return cudaErrorInvalidMemcpyDirection
 
@@ -2348,7 +2353,7 @@ cdef cudaError_t mallocHost(size_t size, void **mem, unsigned int flags) except
         mem[0] = NULL
         return cudaSuccess
     else:
-        return <cudaError_t>ccuda._cuMemHostAlloc(mem, size, flags)
+        return <cudaError_t>cydriver._cuMemHostAlloc(mem, size, flags)
 
 
 cdef cudaError_t mallocPitch(size_t width, size_t height, size_t depth, void **mem, size_t *pitch) except ?cudaErrorCallRequiresNewerDriver nogil:
@@ -2360,7 +2365,7 @@ cdef cudaError_t mallocPitch(size_t width, size_t height, size_t depth, void **m
         mem[0]   = NULL
         pitch[0] = 0
     else:
-        return <cudaError_t>ccuda._cuMemAllocPitch_v2(<ccuda.CUdeviceptr_v2*>mem, pitch, width, height, 4)
+        return <cudaError_t>cydriver._cuMemAllocPitch_v2(<cydriver.CUdeviceptr_v2*>mem, pitch, width, height, 4)
     return cudaSuccess
 
 
@@ -2369,8 +2374,8 @@ cdef cudaError_t mallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cons
     if mipmappedArray == NULL:
         return cudaErrorInvalidValue
 
-    cdef ccuda.CUmipmappedArray mipmap = NULL
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
+    cdef cydriver.CUmipmappedArray mipmap = NULL
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
     memset(&ad, 0, sizeof(ad))
 
     mipmappedArray[0] = NULL
@@ -2388,7 +2393,7 @@ cdef cudaError_t mallocMipmappedArray(cudaMipmappedArray_t *mipmappedArray, cons
         ad.Width  = <unsigned int>width
         ad.Depth  = <unsigned int>depth
         ad.Flags  = flags
-        err = <cudaError_t>ccuda._cuMipmappedArrayCreate(&mipmap, &ad, numLevels)
+        err = <cudaError_t>cydriver._cuMipmappedArrayCreate(&mipmap, &ad, numLevels)
         if err != cudaSuccess:
             return err
         mipmappedArray[0] = <cudaMipmappedArray_t>mipmap
@@ -2401,22 +2406,22 @@ cdef cudaError_t memcpyAsyncDispatch(void *dst, const void *src, size_t size, cu
     elif kind == cudaMemcpyKind.cudaMemcpyHostToHost:
         return memcpy2DPtr(<char*>dst, size, <const char*>src, size, size, 1, kind, stream, True)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
-        return <cudaError_t>ccuda._cuMemcpyDtoHAsync_v2(dst, <ccuda.CUdeviceptr_v2>src, size, stream)
+        return <cudaError_t>cydriver._cuMemcpyDtoHAsync_v2(dst, <cydriver.CUdeviceptr_v2>src, size, stream)
     elif kind == cudaMemcpyKind.cudaMemcpyHostToDevice:
-        return<cudaError_t>ccuda._cuMemcpyHtoDAsync_v2(<ccuda.CUdeviceptr_v2>dst, src, size, stream)
+        return<cudaError_t>cydriver._cuMemcpyHtoDAsync_v2(<cydriver.CUdeviceptr_v2>dst, src, size, stream)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        return<cudaError_t>ccuda._cuMemcpyDtoDAsync_v2(<ccuda.CUdeviceptr_v2>dst, <ccuda.CUdeviceptr_v2>src, size, stream)
+        return<cudaError_t>cydriver._cuMemcpyDtoDAsync_v2(<cydriver.CUdeviceptr_v2>dst, <cydriver.CUdeviceptr_v2>src, size, stream)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        return<cudaError_t>ccuda._cuMemcpyAsync(<ccuda.CUdeviceptr_v2>dst, <ccuda.CUdeviceptr_v2>src, size, stream)
+        return<cudaError_t>cydriver._cuMemcpyAsync(<cydriver.CUdeviceptr_v2>dst, <cydriver.CUdeviceptr_v2>src, size, stream)
     return cudaErrorInvalidMemcpyDirection
 
 
-cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaMemcpy3DParms *p) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t toCudartMemCopy3DParams(const cydriver.CUDA_MEMCPY3D_v2 *cd, cudaMemcpy3DParms *p) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaExtent srcBlockExtent
     cdef cudaExtent dstBlockExtent
     cdef cudaExtent copyBlockExtent
-    cdef ccuda.CUarray_format srcFmt
-    cdef ccuda.CUarray_format dstFmt
+    cdef cydriver.CUarray_format srcFmt
+    cdef cydriver.CUarray_format dstFmt
     cdef int numChannels = 0
     srcBlockExtent.width = srcBlockExtent.height = srcBlockExtent.depth = 1
     dstBlockExtent.width = dstBlockExtent.height = dstBlockExtent.depth = 1
@@ -2426,7 +2431,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
     p[0].srcPtr.xsize = 0
     p[0].dstPtr.xsize = 0
 
-    if (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST and cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST):
+    if (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST and cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST):
         p[0].kind = cudaMemcpyHostToHost
 
         p[0].srcPtr.ptr = <void*>cd[0].srcHost
@@ -2436,26 +2441,26 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
         p[0].dstPtr.ptr = cd[0].dstHost
         p[0].dstPtr.pitch = cd[0].dstPitch
         p[0].dstPtr.ysize = cd[0].dstHeight
-    elif (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST
-            and (cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
-                or cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)):
+    elif (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST
+            and (cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE
+                or cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)):
         p[0].kind = cudaMemcpyHostToDevice
 
         p[0].srcPtr.ptr = <void*>cd[0].srcHost
         p[0].srcPtr.pitch = cd[0].srcPitch
         p[0].srcPtr.ysize = cd[0].srcHeight
 
-        if (cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+        if (cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
             p[0].dstArray = <cudaArray_t>cd[0].dstArray
         else:
             p[0].dstPtr.ptr = <void*>cd[0].dstDevice
             p[0].dstPtr.pitch = cd[0].dstPitch
             p[0].dstPtr.ysize = cd[0].dstHeight
-    elif ((cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
-            and cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST):
+    elif ((cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+            and cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST):
         p[0].kind = cudaMemcpyDeviceToHost
 
-        if (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+        if (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
             p[0].srcArray = <cudaArray_t>cd[0].srcArray
         else:
             p[0].srcPtr.ptr = <void*>cd[0].srcDevice
@@ -2465,24 +2470,24 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
         p[0].dstPtr.ptr = cd[0].dstHost
         p[0].dstPtr.pitch = cd[0].dstPitch
         p[0].dstPtr.ysize = cd[0].dstHeight
-    elif ((cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
-            and (cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)):
+    elif ((cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)
+            and (cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE or cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY)):
         p[0].kind = cudaMemcpyDeviceToDevice
 
-        if (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+        if (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
             p[0].srcArray = <cudaArray_t>cd[0].srcArray
         else:
             p[0].srcPtr.ptr = <void*>cd[0].srcDevice
             p[0].srcPtr.pitch = cd[0].srcPitch
             p[0].srcPtr.ysize = cd[0].srcHeight
 
-        if (cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+        if (cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
             p[0].dstArray = <cudaArray_t>cd[0].dstArray
         else:
             p[0].dstPtr.ptr = <void*>cd[0].dstDevice
             p[0].dstPtr.pitch = cd[0].dstPitch
             p[0].dstPtr.ysize = cd[0].dstHeight
-    elif (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED and cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED):
+    elif (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED and cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED):
         p[0].kind = cudaMemcpyDefault
 
         p[0].srcPtr.ptr = <void*>cd[0].srcDevice
@@ -2492,7 +2497,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
         p[0].dstPtr.ptr = <void*>cd[0].dstDevice
         p[0].dstPtr.pitch = cd[0].dstPitch
         p[0].dstPtr.ysize = cd[0].dstHeight
-    elif (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED and cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+    elif (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED and cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
         p[0].kind = cudaMemcpyDefault
 
         p[0].srcPtr.ptr = <void*>cd[0].srcDevice
@@ -2500,7 +2505,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
         p[0].srcPtr.ysize = cd[0].srcHeight
 
         p[0].dstArray = <cudaArray_t>cd[0].dstArray
-    elif (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY and cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED):
+    elif (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY and cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED):
         p[0].kind = cudaMemcpyDefault
 
         p[0].srcArray = <cudaArray_t>cd[0].srcArray
@@ -2513,9 +2518,9 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
 
     cdef size_t srcElementSize = 0
     cdef size_t dstElementSize = 0
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
 
-    if (cd[0].srcMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+    if (cd[0].srcMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
         err = getFormat(<cudaArray_t>cd[0].srcArray, numChannels, &srcFmt)
         if err != cudaSuccess:
             return err
@@ -2527,7 +2532,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
             return err
         copyBlockExtent = srcBlockExtent
 
-    if (cd[0].dstMemoryType == ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
+    if (cd[0].dstMemoryType == cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY):
         err = getFormat(<cudaArray_t>cd[0].dstArray, numChannels, &dstFmt)
         if err != cudaSuccess:
             return err
@@ -2537,7 +2542,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
         err = getElementSize(&dstElementSize, <cudaArray_t>cd[0].dstArray)
         if err != cudaSuccess:
             return err
-        if cd[0].srcMemoryType != ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY:
+        if cd[0].srcMemoryType != cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY:
             copyBlockExtent = dstBlockExtent
 
     if (srcElementSize and dstElementSize and srcElementSize != dstElementSize):
@@ -2568,7 +2573,7 @@ cdef cudaError_t toCudartMemCopy3DParams(const ccuda.CUDA_MEMCPY3D_v2 *cd, cudaM
 cdef cudaError_t memcpy2DFromArray(char *dst, size_t dpitch, cudaArray_const_t src, size_t hOffset,
         size_t wOffset, size_t width, size_t height, cudaMemcpyKind kind,
         cudaStream_t sid, bool async) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
     if width == 0 or height == 0:
         return cudaSuccess
     if height > 1 and width > dpitch:
@@ -2577,9 +2582,9 @@ cdef cudaError_t memcpy2DFromArray(char *dst, size_t dpitch, cudaArray_const_t s
     if kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
         err = copyToHost2D(src, hOffset, wOffset, dst, dpitch, width, height, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        err = copyToDevice2D(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, src, hOffset, wOffset, dst, 0, dpitch, width, height, sid, async)
+        err = copyToDevice2D(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, src, hOffset, wOffset, dst, 0, dpitch, width, height, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        err = copyToDevice2D(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, src, hOffset, wOffset, dst, 0, dpitch, width, height, sid, async)
+        err = copyToDevice2D(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, src, hOffset, wOffset, dst, 0, dpitch, width, height, sid, async)
     else:
         return cudaErrorInvalidMemcpyDirection
     return err
@@ -2607,7 +2612,7 @@ cdef cudaError_t memset3DPtr(cudaPitchedPtr p, int val, cudaExtent e, cudaStream
 
     cdef char *ptr = <char*>p.ptr
     cdef size_t d
-    cdef cudaError_t err
+    cdef cudaError_t err = cudaSuccess
 
     if e.width >= p.xsize and e.height == p.ysize and e.width == p.pitch:
         return memsetPtr(ptr, val, e.width * e.height * e.depth, sid, async)
@@ -2633,9 +2638,9 @@ cdef cudaError_t memcpyToArray(cudaArray_t dst, size_t hOffset, size_t wOffset,
     if kind == cudaMemcpyKind.cudaMemcpyHostToDevice:
         return copyFromHost(dst, hOffset, wOffset, src, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        return copyFromDevice(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, dst, hOffset, wOffset, src, 0, count, sid, async)
+        return copyFromDevice(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, dst, hOffset, wOffset, src, 0, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        return copyFromDevice(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, dst, hOffset, wOffset, src, 0, count, sid, async)
+        return copyFromDevice(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, dst, hOffset, wOffset, src, 0, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyHostToHost or kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
         return cudaErrorInvalidMemcpyDirection
     return cudaSuccess
@@ -2650,28 +2655,28 @@ cdef cudaError_t memcpyFromArray(char *dst, cudaArray_const_t src, size_t hOffse
     if kind == cudaMemcpyKind.cudaMemcpyDeviceToHost:
         return copyToHost(src, hOffset, wOffset, dst, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDeviceToDevice:
-        return copyToDevice(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, src, hOffset, wOffset, dst, 0, count, sid, async)
+        return copyToDevice(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE, src, hOffset, wOffset, dst, 0, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyDefault:
-        return copyToDevice(ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, src, hOffset, wOffset, dst, 0, count, sid, async)
+        return copyToDevice(cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED, src, hOffset, wOffset, dst, 0, count, sid, async)
     elif kind == cudaMemcpyKind.cudaMemcpyHostToDevice or kind == cudaMemcpyKind.cudaMemcpyHostToHost:
         return cudaErrorInvalidMemcpyDirection
     return cudaSuccess
 
 
-cdef cudaError_t toDriverCudaResourceDesc(ccuda.CUDA_RESOURCE_DESC *_driver_pResDesc, const cudaResourceDesc *pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t toDriverCudaResourceDesc(cydriver.CUDA_RESOURCE_DESC *_driver_pResDesc, const cudaResourceDesc *pResDesc) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaError_t err = cudaSuccess
     cdef int numChannels
-    cdef ccuda.CUarray_format format
+    cdef cydriver.CUarray_format format
 
     if pResDesc[0].resType == cudaResourceType.cudaResourceTypeArray:
-        _driver_pResDesc[0].resType          = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY
-        _driver_pResDesc[0].res.array.hArray = <ccuda.CUarray>pResDesc[0].res.array.array
+        _driver_pResDesc[0].resType          = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY
+        _driver_pResDesc[0].res.array.hArray = <cydriver.CUarray>pResDesc[0].res.array.array
     elif pResDesc[0].resType == cudaResourceType.cudaResourceTypeMipmappedArray:
-        _driver_pResDesc[0].resType                    = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
-        _driver_pResDesc[0].res.mipmap.hMipmappedArray = <ccuda.CUmipmappedArray>pResDesc[0].res.mipmap.mipmap
+        _driver_pResDesc[0].resType                    = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
+        _driver_pResDesc[0].res.mipmap.hMipmappedArray = <cydriver.CUmipmappedArray>pResDesc[0].res.mipmap.mipmap
     elif pResDesc[0].resType == cudaResourceType.cudaResourceTypeLinear:
-        _driver_pResDesc[0].resType                = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR
-        _driver_pResDesc[0].res.linear.devPtr      = <ccuda.CUdeviceptr>pResDesc[0].res.linear.devPtr
+        _driver_pResDesc[0].resType                = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR
+        _driver_pResDesc[0].res.linear.devPtr      = <cydriver.CUdeviceptr>pResDesc[0].res.linear.devPtr
         _driver_pResDesc[0].res.linear.sizeInBytes = pResDesc[0].res.linear.sizeInBytes
         err = getDescInfo(&pResDesc[0].res.linear.desc, &numChannels, &format)
         if err != cudaSuccess:
@@ -2680,8 +2685,8 @@ cdef cudaError_t toDriverCudaResourceDesc(ccuda.CUDA_RESOURCE_DESC *_driver_pRes
         _driver_pResDesc[0].res.linear.format      = format
         _driver_pResDesc[0].res.linear.numChannels = numChannels
     elif pResDesc[0].resType == cudaResourceType.cudaResourceTypePitch2D:
-        _driver_pResDesc[0].resType                  = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D
-        _driver_pResDesc[0].res.pitch2D.devPtr       = <ccuda.CUdeviceptr>pResDesc[0].res.pitch2D.devPtr
+        _driver_pResDesc[0].resType                  = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D
+        _driver_pResDesc[0].res.pitch2D.devPtr       = <cydriver.CUdeviceptr>pResDesc[0].res.pitch2D.devPtr
         _driver_pResDesc[0].res.pitch2D.pitchInBytes = pResDesc[0].res.pitch2D.pitchInBytes
         _driver_pResDesc[0].res.pitch2D.width        = pResDesc[0].res.pitch2D.width
         _driver_pResDesc[0].res.pitch2D.height       = pResDesc[0].res.pitch2D.height
@@ -2699,7 +2704,7 @@ cdef cudaError_t toDriverCudaResourceDesc(ccuda.CUDA_RESOURCE_DESC *_driver_pRes
     return err
 
 
-cdef cudaError_t getDriverEglFrame(ccuda.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil:
+cdef cudaError_t getDriverEglFrame(cydriver.CUeglFrame *cuEglFrame, cudaEglFrame eglFrame) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaError_t err = cudaSuccess
     cdef unsigned int i = 0
 
@@ -2708,7 +2713,7 @@ cdef cudaError_t getDriverEglFrame(ccuda.CUeglFrame *cuEglFrame, cudaEglFrame eg
         return err
     for i in range(eglFrame.planeCount):
         if eglFrame.frameType == cudaEglFrameTypeArray:
-            cuEglFrame[0].frame.pArray[i] = <ccuda.CUarray>eglFrame.frame.pArray[i]
+            cuEglFrame[0].frame.pArray[i] = <cydriver.CUarray>eglFrame.frame.pArray[i]
         else:
             cuEglFrame[0].frame.pPitch[i] = eglFrame.frame.pPitch[i].ptr
     cuEglFrame[0].width = eglFrame.planeDesc[0].width
@@ -2717,241 +2722,243 @@ cdef cudaError_t getDriverEglFrame(ccuda.CUeglFrame *cuEglFrame, cudaEglFrame eg
     cuEglFrame[0].pitch = eglFrame.planeDesc[0].pitch
     cuEglFrame[0].planeCount = eglFrame.planeCount
     if eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV422:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422
     elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY422:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422
     elif eglFrame.eglColorFormat == cudaEglColorFormatARGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatRGBA:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA
     elif eglFrame.eglColorFormat == cudaEglColorFormatABGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBGRA:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA
     elif eglFrame.eglColorFormat == cudaEglColorFormatL:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L
     elif eglFrame.eglColorFormat == cudaEglColorFormatR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R
     elif eglFrame.eglColorFormat == cudaEglColorFormatA:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A
     elif eglFrame.eglColorFormat == cudaEglColorFormatRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG
     elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatUYVY_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUYV_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatAYUV_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV444SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV422SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerGBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10RGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10BGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10GBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12GBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14RGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14BGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer14GBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20RGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20BGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer20GBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspRGGB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspBGGR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGRBG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerIspGBRG:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU444Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU422Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerBCCR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerRCCB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCRBC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayerCBRC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer10CCCC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12BCCR:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12RCCB:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CRBC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CBRC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC
     elif eglFrame.eglColorFormat == cudaEglColorFormatBayer12CCCC:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC
     elif eglFrame.eglColorFormat == cudaEglColorFormatY:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420SemiPlanar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420SemiPlanar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUV420Planar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVU420Planar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_2020:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_422SemiPlanar_709:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709
     elif eglFrame.eglColorFormat == cudaEglColorFormatY_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatYUVA:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA
     elif eglFrame.eglColorFormat == cudaEglColorFormatYVYU:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU
     elif eglFrame.eglColorFormat == cudaEglColorFormatVYUY:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat =  ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat =  cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER
     elif eglFrame.eglColorFormat == cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER:
-        cuEglFrame[0].eglColorFormat = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER
+        cuEglFrame[0].eglColorFormat = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER
     else:
         return cudaErrorInvalidValue
     if eglFrame.frameType == cudaEglFrameTypeArray:
-        cuEglFrame[0].frameType = ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY
+        cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY
     elif eglFrame.frameType == cudaEglFrameTypePitch:
-        cuEglFrame[0].frameType = ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH
+        cuEglFrame[0].frameType = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH
     else:
         return cudaErrorInvalidValue
 
 
-cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, ccuda.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil:
+@cython.show_performance_hints(False)
+cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, cydriver.CUeglFrame cueglFrame) except ?cudaErrorCallRequiresNewerDriver nogil:
     cdef cudaError_t err = cudaSuccess
     cdef unsigned int i
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2 ad
     cdef cudaPitchedPtr pPtr
     memset(eglFrame, 0, sizeof(eglFrame[0]))
+    memset(&ad, 0, sizeof(ad))
     for i in range(cueglFrame.planeCount):
         ad.Depth = cueglFrame.depth
         ad.Flags = 0
@@ -2970,97 +2977,97 @@ cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, ccuda.CUeglFrame cue
             eglFrame[0].planeDesc[i].width = cueglFrame.width
             eglFrame[0].planeDesc[i].height = cueglFrame.height
             eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709):
             eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2)
             eglFrame[0].planeDesc[i].height = <unsigned int>(cueglFrame.height / 2)
             eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2)
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 or 
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 or 
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER):
             eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2)
             eglFrame[0].planeDesc[i].height = <unsigned int>(cueglFrame.height / 2)
             eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2)
             eglFrame[0].planeDesc[1].channelDesc.y = 8
-            if (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER):
+            if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER):
                 eglFrame[0].planeDesc[1].channelDesc.y = 16
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER):
             eglFrame[0].planeDesc[i].height = cueglFrame.height
             eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2)
             eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2)
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709):
             eglFrame[0].planeDesc[i].width = <unsigned int>(cueglFrame.width / 2)
             eglFrame[0].planeDesc[i].height = cueglFrame.height
             eglFrame[0].planeDesc[i].pitch = <unsigned int>(cueglFrame.pitch / 2)
             eglFrame[0].planeDesc[1].channelDesc.y = 8
-            if (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709):
+            if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709):
                 eglFrame[0].planeDesc[1].channelDesc.y = 16
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER):
             eglFrame[0].planeDesc[i].height = cueglFrame.height
             eglFrame[0].planeDesc[i].width = cueglFrame.width
             eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch
-        elif (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or
-              cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER):
+        elif (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or
+              cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER):
             eglFrame[0].planeDesc[i].height = cueglFrame.height
             eglFrame[0].planeDesc[i].width = cueglFrame.width
             eglFrame[0].planeDesc[i].pitch = cueglFrame.pitch
             eglFrame[0].planeDesc[1].channelDesc.y = 8
-            if (cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or
-                cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER):
+            if (cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER or
+                cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER):
                 eglFrame[0].planeDesc[1].channelDesc.y = 16
-        if cueglFrame.frameType == ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY:
+        if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY:
             eglFrame[0].frame.pArray[i] = <cudaArray_t>cueglFrame.frame.pArray[i]
         else:
             pPtr = make_cudaPitchedPtr(cueglFrame.frame.pPitch[i], eglFrame[0].planeDesc[i].pitch,
@@ -3068,231 +3075,231 @@ cdef cudaError_t getRuntimeEglFrame(cudaEglFrame *eglFrame, ccuda.CUeglFrame cue
             eglFrame[0].frame.pPitch[i] = pPtr
 
     eglFrame[0].planeCount = cueglFrame.planeCount
-    if cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR:
+    if cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV422
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422:
         eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY422
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatARGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA:
         eglFrame[0].eglColorFormat = cudaEglColorFormatRGBA
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatABGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBGRA
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L:
         eglFrame[0].eglColorFormat = cudaEglColorFormatL
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R:
         eglFrame[0].eglColorFormat = cudaEglColorFormatR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A:
         eglFrame[0].eglColorFormat = cudaEglColorFormatA
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV:
         eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatUYVY_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUYV_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatAYUV_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV444SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV422SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerGBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10RGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10BGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10GBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12GBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14RGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14BGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer14GBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20RGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20BGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer20GBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspRGGB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspBGGR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGRBG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerIspGBRG
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU444Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU422Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerBCCR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerRCCB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCRBC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayerCBRC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer10CCCC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12BCCR
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12RCCB
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CRBC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CBRC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC:
         eglFrame[0].eglColorFormat = cudaEglColorFormatBayer12CCCC
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420SemiPlanar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420SemiPlanar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUV420Planar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVU420Planar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_2020
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_422SemiPlanar_709
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYUVA
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU:
         eglFrame[0].eglColorFormat = cudaEglColorFormatYVYU
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY:
         eglFrame[0].eglColorFormat = cudaEglColorFormatVYUY
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_ER
-    elif cueglFrame.eglColorFormat == ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER:
+    elif cueglFrame.eglColorFormat == cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER:
         eglFrame[0].eglColorFormat = cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER
     else:
         return cudaErrorInvalidValue
-    if cueglFrame.frameType == ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY:
+    if cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY:
         eglFrame[0].frameType = cudaEglFrameTypeArray
-    elif cueglFrame.frameType == ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH:
+    elif cueglFrame.frameType == cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH:
         eglFrame[0].frameType = cudaEglFrameTypePitch
     else:
         return cudaErrorInvalidValue
diff --git a/cuda/_lib/dlfcn.pxd b/cuda/cuda/bindings/_lib/dlfcn.pxd
similarity index 89%
rename from cuda/_lib/dlfcn.pxd
rename to cuda/cuda/bindings/_lib/dlfcn.pxd
index e1a45c8d..808c7186 100644
--- a/cuda/_lib/dlfcn.pxd
+++ b/cuda/cuda/bindings/_lib/dlfcn.pxd
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
diff --git a/cuda/_lib/param_packer.cpp b/cuda/cuda/bindings/_lib/param_packer.cpp
similarity index 98%
rename from cuda/_lib/param_packer.cpp
rename to cuda/cuda/bindings/_lib/param_packer.cpp
index 09db58d7..63386a17 100644
--- a/cuda/_lib/param_packer.cpp
+++ b/cuda/cuda/bindings/_lib/param_packer.cpp
@@ -1,4 +1,4 @@
-// Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+// Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 //
 // Please refer to the NVIDIA end user license agreement (EULA) associated
 // with this source code for terms and conditions that govern your use of
diff --git a/cuda/_lib/param_packer.h b/cuda/cuda/bindings/_lib/param_packer.h
similarity index 86%
rename from cuda/_lib/param_packer.h
rename to cuda/cuda/bindings/_lib/param_packer.h
index d6a5c4f4..2dfa4deb 100644
--- a/cuda/_lib/param_packer.h
+++ b/cuda/cuda/bindings/_lib/param_packer.h
@@ -1,4 +1,4 @@
-// Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+// Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 //
 // Please refer to the NVIDIA end user license agreement (EULA) associated
 // with this source code for terms and conditions that govern your use of
diff --git a/cuda/_lib/param_packer.pxd b/cuda/cuda/bindings/_lib/param_packer.pxd
similarity index 86%
rename from cuda/_lib/param_packer.pxd
rename to cuda/cuda/bindings/_lib/param_packer.pxd
index 9a81a4de..440006f5 100644
--- a/cuda/_lib/param_packer.pxd
+++ b/cuda/cuda/bindings/_lib/param_packer.pxd
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
diff --git a/cuda/_lib/utils.pxd.in b/cuda/cuda/bindings/_lib/utils.pxd.in
similarity index 72%
rename from cuda/_lib/utils.pxd.in
rename to cuda/cuda/bindings/_lib/utils.pxd.in
index 62cc1b39..c5897026 100644
--- a/cuda/_lib/utils.pxd.in
+++ b/cuda/cuda/bindings/_lib/utils.pxd.in
@@ -1,12 +1,12 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda.cuda as cuda
-cimport cuda.ccuda as ccuda
+cimport cuda.bindings.driver as driver
+cimport cuda.bindings.cydriver as cydriver
 from libcpp.vector cimport vector
 
 cdef class HelperKernelParams:
@@ -25,18 +25,18 @@ cdef class HelperInputVoidPtr:
 
 cdef class HelperCUmemPool_attribute:
     cdef void* _cptr
-    cdef ccuda.CUmemPool_attribute_enum _attr
+    cdef cydriver.CUmemPool_attribute_enum _attr
     cdef bint _is_getter
 
     # Return values
     cdef int _int_val
-    cdef cuda.cuuint64_t _cuuint64_t_val
+    cdef driver.cuuint64_t _cuuint64_t_val
 {{endif}}
 {{if 'CUmem_range_attribute_enum' in found_types}}
 
 cdef class HelperCUmem_range_attribute:
     cdef void* _cptr
-    cdef ccuda.CUmem_range_attribute_enum _attr
+    cdef cydriver.CUmem_range_attribute_enum _attr
     cdef size_t _data_size
 
     # Return values
@@ -47,44 +47,44 @@ cdef class HelperCUmem_range_attribute:
 
 cdef class HelperCUpointer_attribute:
     cdef void* _cptr
-    cdef ccuda.CUpointer_attribute_enum _attr
+    cdef cydriver.CUpointer_attribute_enum _attr
     cdef bint _is_getter
 
     # Return values
-    cdef cuda.CUcontext _ctx
+    cdef driver.CUcontext _ctx
     cdef unsigned int _uint
-    cdef cuda.CUdeviceptr _devptr
+    cdef driver.CUdeviceptr _devptr
     cdef void** _void
-    cdef cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS _token
+    cdef driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS _token
     cdef bint _bool
     cdef unsigned long long _ull
     cdef size_t _size
-    cdef cuda.CUmemoryPool _mempool
+    cdef driver.CUmemoryPool _mempool
 {{endif}}
 {{if 'CUgraphMem_attribute_enum' in found_types}}
 
 cdef class HelperCUgraphMem_attribute:
     cdef void* _cptr
-    cdef ccuda.CUgraphMem_attribute_enum _attr
+    cdef cydriver.CUgraphMem_attribute_enum _attr
     cdef bint _is_getter
 
     # Return values
-    cdef cuda.cuuint64_t _cuuint64_t_val
+    cdef driver.cuuint64_t _cuuint64_t_val
 {{endif}}
 {{if 'CUjit_option_enum' in found_types}}
 
 cdef class HelperCUjit_option:
     cdef void* _cptr
-    cdef ccuda.CUjit_option_enum _attr
+    cdef cydriver.CUjit_option_enum _attr
 
     # Return values
     cdef unsigned int _uint
     cdef float _float
     cdef char* _charstar
-    cdef ccuda.CUjit_target_enum _target
-    cdef ccuda.CUjit_fallback_enum _fallback
+    cdef cydriver.CUjit_target_enum _target
+    cdef cydriver.CUjit_fallback_enum _fallback
     cdef int _int
-    cdef ccuda.CUjit_cacheMode_enum _cacheMode
+    cdef cydriver.CUjit_cacheMode_enum _cacheMode
     cdef vector[char*] _charstarstar # list of names
     cdef InputVoidPtrPtrHelper _voidstarstar # list of addresses
 {{endif}}
@@ -92,7 +92,7 @@ cdef class HelperCUjit_option:
 
 cdef class HelperCUmemAllocationHandleType:
     cdef void* _cptr
-    cdef ccuda.CUmemAllocationHandleType_enum _type
+    cdef cydriver.CUmemAllocationHandleType_enum _type
 
     # Return values
     cdef int _int
diff --git a/cuda/_lib/utils.pyx.in b/cuda/cuda/bindings/_lib/utils.pyx.in
similarity index 70%
rename from cuda/_lib/utils.pyx.in
rename to cuda/cuda/bindings/_lib/utils.pyx.in
index efb38cca..a0787cca 100644
--- a/cuda/_lib/utils.pyx.in
+++ b/cuda/cuda/bindings/_lib/utils.pyx.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -13,9 +13,9 @@ from libc.string cimport memcpy
 from enum import Enum
 from typing import List, Tuple
 import ctypes
-cimport cuda.ccuda as ccuda
-import cuda.cuda as cuda
-cimport cuda._lib.param_packer as param_packer
+cimport cuda.bindings.cydriver as cydriver
+import cuda.bindings.driver as driver
+cimport cuda.bindings._lib.param_packer as param_packer
 
 ctypedef unsigned long long void_ptr
 
@@ -166,18 +166,18 @@ cdef class HelperCUmemPool_attribute:
     def __cinit__(self, attr, init_value, is_getter=False):
         self._is_getter = is_getter
         self._attr = attr.value
-        if self._attr in ({{if 'CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,{{endif}}
-                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,{{endif}}
-                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,{{endif}}):
+        if self._attr in ({{if 'CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,{{endif}}
+                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,{{endif}}
+                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,{{endif}}):
             self._int_val = init_value
             self._cptr = <void*>&self._int_val
-        elif self._attr in ({{if 'CU_MEMPOOL_ATTR_RELEASE_THRESHOLD'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,{{endif}}):
+        elif self._attr in ({{if 'CU_MEMPOOL_ATTR_RELEASE_THRESHOLD'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,{{endif}}):
             if self._is_getter:
-                self._cuuint64_t_val = cuda.cuuint64_t()
+                self._cuuint64_t_val = driver.cuuint64_t()
                 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -193,15 +193,15 @@ cdef class HelperCUmemPool_attribute:
 
     def pyObj(self):
         assert(self._is_getter == True)
-        if self._attr in ({{if 'CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,{{endif}}
-                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,{{endif}}
-                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,{{endif}}):
+        if self._attr in ({{if 'CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES,{{endif}}
+                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC,{{endif}}
+                          {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES,{{endif}}):
             return self._int_val
-        elif self._attr in ({{if 'CU_MEMPOOL_ATTR_RELEASE_THRESHOLD'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,{{endif}}
-                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH'}}ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,{{endif}}):
+        elif self._attr in ({{if 'CU_MEMPOOL_ATTR_RELEASE_THRESHOLD'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT,{{endif}}
+                            {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH'}}cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH,{{endif}}):
             return self._cuuint64_t_val
         else:
             raise TypeError('Unsupported attribute value: {}'.format(self._attr))
@@ -212,18 +212,18 @@ cdef class HelperCUmem_range_attribute:
     def __cinit__(self, attr, data_size):
         self._data_size = data_size
         self._attr = attr.value
-        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,{{endif}}
-                          {{if 'CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,{{endif}}
-                          {{if 'CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,{{endif}}):
+        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,{{endif}}
+                          {{if 'CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,{{endif}}
+                          {{if 'CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,{{endif}}):
             self._cptr = <void*>&self._int_val
-        elif self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
+        elif self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
             self._cptr = callocWrapper(1, self._data_size)
             self._int_val_list = <int*>self._cptr
         else:
             raise TypeError('Unsupported attribute: {}'.format(attr.name))
 
     def __dealloc__(self):
-        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
+        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
             free(self._cptr)
 
     @property
@@ -231,11 +231,11 @@ cdef class HelperCUmem_range_attribute:
         return <void_ptr>self._cptr
 
     def pyObj(self):
-        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,{{endif}}
-                          {{if 'CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,{{endif}}
-                          {{if 'CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,{{endif}}):
+        if self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY,{{endif}}
+                          {{if 'CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION,{{endif}}
+                          {{if 'CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION,{{endif}}):
             return self._int_val
-        elif self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
+        elif self._attr in ({{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY'}}cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY,{{endif}}):
             return [self._int_val_list[idx] for idx in range(int(self._data_size/4))]
         else:
             raise TypeError('Unsupported attribute value: {}'.format(self._attr))
@@ -246,50 +246,50 @@ cdef class HelperCUpointer_attribute:
     def __cinit__(self, attr, init_value, is_getter=False):
         self._is_getter = is_getter
         self._attr = attr.value
-        if self._attr in ({{if 'CU_POINTER_ATTRIBUTE_CONTEXT'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,{{endif}}):
+        if self._attr in ({{if 'CU_POINTER_ATTRIBUTE_CONTEXT'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,{{endif}}):
             if self._is_getter:
-                self._ctx = cuda.CUcontext()
+                self._ctx = driver.CUcontext()
                 self._cptr = <void*><void_ptr>self._ctx.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,{{endif}}):
             self._uint = init_value
             self._cptr = <void*>&self._uint
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
             if self._is_getter:
-                self._devptr = cuda.CUdeviceptr()
+                self._devptr = driver.CUdeviceptr()
                 self._cptr = <void*><void_ptr>self._devptr.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_HOST_POINTER'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_HOST_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,{{endif}}):
             self._void = <void**><void_ptr>init_value
             self._cptr = <void*>&self._void
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,{{endif}}):
             if self._is_getter:
-                self._token = cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS()
+                self._token = driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS()
                 self._cptr = <void*><void_ptr>self._token.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_SYNC_MEMOPS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_MANAGED'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_MAPPED'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_SYNC_MEMOPS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_MANAGED'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_MAPPED'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,{{endif}}):
             self._bool = init_value
             self._cptr = <void*>&self._bool
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_BUFFER_ID'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_BUFFER_ID'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,{{endif}}):
             self._ull = init_value
             self._cptr = <void*>&self._ull
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_RANGE_SIZE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_RANGE_SIZE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,{{endif}}):
             self._size = init_value
             self._cptr = <void*>&self._size
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,{{endif}}):
             if self._is_getter:
-                self._mempool = cuda.CUmemoryPool()
+                self._mempool = driver.CUmemoryPool()
                 self._cptr = <void*><void_ptr>self._mempool.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -305,31 +305,31 @@ cdef class HelperCUpointer_attribute:
 
     def pyObj(self):
         assert(self._is_getter == True)
-        if self._attr in ({{if 'CU_POINTER_ATTRIBUTE_CONTEXT'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,{{endif}}):
+        if self._attr in ({{if 'CU_POINTER_ATTRIBUTE_CONTEXT'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT,{{endif}}):
             return self._ctx
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS,{{endif}}):
             return self._uint
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR,{{endif}}):
             return self._devptr
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_HOST_POINTER'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_HOST_POINTER'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER,{{endif}}):
             return <void_ptr>self._void
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS,{{endif}}):
             return self._token
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_SYNC_MEMOPS'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_MANAGED'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,{{endif}}
-                            {{if 'CU_POINTER_ATTRIBUTE_MAPPED'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_SYNC_MEMOPS'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_MANAGED'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE,{{endif}}
+                            {{if 'CU_POINTER_ATTRIBUTE_MAPPED'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED,{{endif}}):
             return self._bool
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_BUFFER_ID'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_BUFFER_ID'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID,{{endif}}):
             return self._ull
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_RANGE_SIZE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_RANGE_SIZE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE,{{endif}}):
             return self._size
-        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE'}}ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,{{endif}}):
+        elif self._attr in ({{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE'}}cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE,{{endif}}):
             return self._mempool
         else:
             raise TypeError('Unsupported attribute value: {}'.format(self._attr))
@@ -340,12 +340,12 @@ cdef class HelperCUgraphMem_attribute:
     def __cinit__(self, attr, init_value, is_getter=False):
         self._is_getter = is_getter
         self._attr = attr.value
-        if self._attr in ({{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,{{endif}}):
+        if self._attr in ({{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,{{endif}}):
             if self._is_getter:
-                self._cuuint64_t_val = cuda.cuuint64_t()
+                self._cuuint64_t_val = driver.cuuint64_t()
                 self._cptr = <void*><void_ptr>self._cuuint64_t_val.getPtr()
             else:
                 self._cptr = <void*><void_ptr>init_value.getPtr()
@@ -361,10 +361,10 @@ cdef class HelperCUgraphMem_attribute:
 
     def pyObj(self):
         assert(self._is_getter == True)
-        if self._attr in ({{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,{{endif}}
-                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,{{endif}}):
+        if self._attr in ({{if 'CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT,{{endif}}
+                          {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH,{{endif}}):
             return self._cuuint64_t_val
         else:
             raise TypeError('Unsupported attribute value: {}'.format(self._attr))
@@ -374,45 +374,45 @@ cdef class HelperCUgraphMem_attribute:
 cdef class HelperCUjit_option:
     def __cinit__(self, attr, init_value):
         self._attr = attr.value
-        if self._attr in ({{if 'CU_JIT_MAX_REGISTERS' in found_values}}ccuda.CUjit_option_enum.CU_JIT_MAX_REGISTERS,{{endif}}
-                          {{if 'CU_JIT_THREADS_PER_BLOCK' in found_values}}ccuda.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK,{{endif}}
-                          {{if 'CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES' in found_values}}ccuda.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,{{endif}}
-                          {{if 'CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES' in found_values}}ccuda.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,{{endif}}
-                          {{if 'CU_JIT_OPTIMIZATION_LEVEL' in found_values}}ccuda.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL,{{endif}}
-                          {{if 'CU_JIT_GLOBAL_SYMBOL_COUNT' in found_values}}ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT,{{endif}}
-                          {{if 'CU_JIT_TARGET_FROM_CUCONTEXT' in found_values}}ccuda.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT,{{endif}}):
+        if self._attr in ({{if 'CU_JIT_MAX_REGISTERS' in found_values}}cydriver.CUjit_option_enum.CU_JIT_MAX_REGISTERS,{{endif}}
+                          {{if 'CU_JIT_THREADS_PER_BLOCK' in found_values}}cydriver.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK,{{endif}}
+                          {{if 'CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES' in found_values}}cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES,{{endif}}
+                          {{if 'CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES' in found_values}}cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES,{{endif}}
+                          {{if 'CU_JIT_OPTIMIZATION_LEVEL' in found_values}}cydriver.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL,{{endif}}
+                          {{if 'CU_JIT_GLOBAL_SYMBOL_COUNT' in found_values}}cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT,{{endif}}
+                          {{if 'CU_JIT_TARGET_FROM_CUCONTEXT' in found_values}}cydriver.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT,{{endif}}):
             self._uint = init_value
             self._cptr = <void*><void_ptr>self._uint
-        elif self._attr in ({{if 'CU_JIT_WALL_TIME' in found_values}}ccuda.CUjit_option_enum.CU_JIT_WALL_TIME,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_WALL_TIME' in found_values}}cydriver.CUjit_option_enum.CU_JIT_WALL_TIME,{{endif}}):
             self._float = init_value
             self._cptr = <void*><void_ptr>self._float
-        elif self._attr in ({{if 'CU_JIT_INFO_LOG_BUFFER' in found_values}}ccuda.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER,{{endif}}
-                            {{if 'CU_JIT_ERROR_LOG_BUFFER' in found_values}}ccuda.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_INFO_LOG_BUFFER' in found_values}}cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER,{{endif}}
+                            {{if 'CU_JIT_ERROR_LOG_BUFFER' in found_values}}cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER{{endif}}):
             self._charstar = init_value
             self._cptr = <void*><void_ptr>self._charstar
-        elif self._attr in ({{if 'CU_JIT_TARGET' in found_values}}ccuda.CUjit_option_enum.CU_JIT_TARGET,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_TARGET' in found_values}}cydriver.CUjit_option_enum.CU_JIT_TARGET,{{endif}}):
             self._target = init_value.value
             self._cptr = <void*><void_ptr>self._target
-        elif self._attr in ({{if 'CU_JIT_FALLBACK_STRATEGY' in found_values}}ccuda.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_FALLBACK_STRATEGY' in found_values}}cydriver.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY,{{endif}}):
             self._fallback = init_value.value
             self._cptr = <void*><void_ptr>self._fallback
-        elif self._attr in ({{if 'CU_JIT_GENERATE_DEBUG_INFO' in found_values}}ccuda.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO,{{endif}}
-                            {{if 'CU_JIT_LOG_VERBOSE' in found_values}}ccuda.CUjit_option_enum.CU_JIT_LOG_VERBOSE,{{endif}}
-                            {{if 'CU_JIT_GENERATE_LINE_INFO' in found_values}}ccuda.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO,{{endif}}
-                            {{if 'CU_JIT_LTO' in found_values}}ccuda.CUjit_option_enum.CU_JIT_LTO,{{endif}}
-                            {{if 'CU_JIT_FTZ' in found_values}}ccuda.CUjit_option_enum.CU_JIT_FTZ,{{endif}}
-                            {{if 'CU_JIT_PREC_DIV' in found_values}}ccuda.CUjit_option_enum.CU_JIT_PREC_DIV,{{endif}}
-                            {{if 'CU_JIT_PREC_SQRT' in found_values}}ccuda.CUjit_option_enum.CU_JIT_PREC_SQRT,{{endif}}
-                            {{if 'CU_JIT_FMA' in found_values}}ccuda.CUjit_option_enum.CU_JIT_FMA,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_GENERATE_DEBUG_INFO' in found_values}}cydriver.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO,{{endif}}
+                            {{if 'CU_JIT_LOG_VERBOSE' in found_values}}cydriver.CUjit_option_enum.CU_JIT_LOG_VERBOSE,{{endif}}
+                            {{if 'CU_JIT_GENERATE_LINE_INFO' in found_values}}cydriver.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO,{{endif}}
+                            {{if 'CU_JIT_LTO' in found_values}}cydriver.CUjit_option_enum.CU_JIT_LTO,{{endif}}
+                            {{if 'CU_JIT_FTZ' in found_values}}cydriver.CUjit_option_enum.CU_JIT_FTZ,{{endif}}
+                            {{if 'CU_JIT_PREC_DIV' in found_values}}cydriver.CUjit_option_enum.CU_JIT_PREC_DIV,{{endif}}
+                            {{if 'CU_JIT_PREC_SQRT' in found_values}}cydriver.CUjit_option_enum.CU_JIT_PREC_SQRT,{{endif}}
+                            {{if 'CU_JIT_FMA' in found_values}}cydriver.CUjit_option_enum.CU_JIT_FMA,{{endif}}):
             self._int = init_value
             self._cptr = <void*><void_ptr>self._int
-        elif self._attr in ({{if 'CU_JIT_CACHE_MODE' in found_values}}ccuda.CUjit_option_enum.CU_JIT_CACHE_MODE,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_CACHE_MODE' in found_values}}cydriver.CUjit_option_enum.CU_JIT_CACHE_MODE,{{endif}}):
             self._cacheMode = init_value.value
             self._cptr = <void*><void_ptr>self._cacheMode
-        elif self._attr in ({{if 'CU_JIT_GLOBAL_SYMBOL_NAMES' in found_values}}ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_GLOBAL_SYMBOL_NAMES' in found_values}}cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES,{{endif}}):
             self._charstarstar = init_value
             self._cptr = <void*>&self._charstarstar[0]
-        elif self._attr in ({{if 'CU_JIT_GLOBAL_SYMBOL_ADDRESSES' in found_values}}ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES,{{endif}}):
+        elif self._attr in ({{if 'CU_JIT_GLOBAL_SYMBOL_ADDRESSES' in found_values}}cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES,{{endif}}):
             pylist = [HelperInputVoidPtr(val) for val in init_value]
             self._voidstarstar = InputVoidPtrPtrHelper(pylist)
             self._cptr = <void*><void_ptr>self._voidstarstar.cptr
@@ -434,19 +434,19 @@ cdef class HelperCUmemAllocationHandleType:
         if False:
             pass
         {{if 'CU_MEM_HANDLE_TYPE_NONE' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
             self._cptr = <void*>&self._int
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
             self._cptr = <void*>&self._int
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_WIN32' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
             self._cptr = <void*>&self._handle
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_WIN32_KMT' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
             self._cptr = <void*>&self._d3dkmt_handle
         {{endif}}
         else:
@@ -463,19 +463,19 @@ cdef class HelperCUmemAllocationHandleType:
         if False:
             pass
         {{if 'CU_MEM_HANDLE_TYPE_NONE' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE,):
             return self._int
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR,):
             return self._int
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_WIN32' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32,):
             return <void_ptr>self._handle
         {{endif}}
         {{if 'CU_MEM_HANDLE_TYPE_WIN32_KMT' in found_values}}
-        elif self._type in (ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
+        elif self._type in (cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT,):
             return self._d3dkmt_handle
         {{endif}}
         else:
diff --git a/cuda/_version.py b/cuda/cuda/bindings/_version.py
similarity index 83%
rename from cuda/_version.py
rename to cuda/cuda/bindings/_version.py
index 8de2ad56..03e1a0b1 100644
--- a/cuda/_version.py
+++ b/cuda/cuda/bindings/_version.py
@@ -5,8 +5,9 @@
 # directories (produced by setup.py build) will contain a much shorter file
 # that just contains the computed version number.
 
-# This file is released into the public domain. Generated by
-# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer)
+# This file is released into the public domain.
+# Generated by versioneer-0.29
+# https://github.com/python-versioneer/python-versioneer
 
 """Git implementation of _version.py."""
 
@@ -15,9 +16,11 @@
 import re
 import subprocess
 import sys
+from typing import Any, Callable, Dict, List, Optional, Tuple
+import functools
 
 
-def get_keywords():
+def get_keywords() -> Dict[str, str]:
     """Get the keywords needed to look up the version information."""
     # these strings will be replaced by git during git-archive.
     # setup.py/versioneer.py will grep for the variable names, so they must
@@ -30,11 +33,18 @@ def get_keywords():
     return keywords
 
 
-class VersioneerConfig:  # pylint: disable=too-few-public-methods
+class VersioneerConfig:
     """Container for Versioneer configuration parameters."""
 
+    VCS: str
+    style: str
+    tag_prefix: str
+    parentdir_prefix: str
+    versionfile_source: str
+    verbose: bool
 
-def get_config():
+
+def get_config() -> VersioneerConfig:
     """Create, populate and return the VersioneerConfig() object."""
     # these strings are filled in when 'setup.py versioneer' creates
     # _version.py
@@ -52,13 +62,13 @@ class NotThisMethod(Exception):
     """Exception raised if a method is not valid for the current scenario."""
 
 
-LONG_VERSION_PY = {}
-HANDLERS = {}
+LONG_VERSION_PY: Dict[str, str] = {}
+HANDLERS: Dict[str, Dict[str, Callable]] = {}
 
 
-def register_vcs_handler(vcs, method):  # decorator
+def register_vcs_handler(vcs: str, method: str) -> Callable:  # decorator
     """Create decorator to mark a method as the handler of a VCS."""
-    def decorate(f):
+    def decorate(f: Callable) -> Callable:
         """Store f in HANDLERS[vcs][method]."""
         if vcs not in HANDLERS:
             HANDLERS[vcs] = {}
@@ -67,12 +77,25 @@ def decorate(f):
     return decorate
 
 
-# pylint:disable=too-many-arguments,consider-using-with # noqa
-def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
-                env=None):
+def run_command(
+    commands: List[str],
+    args: List[str],
+    cwd: Optional[str] = None,
+    verbose: bool = False,
+    hide_stderr: bool = False,
+    env: Optional[Dict[str, str]] = None,
+) -> Tuple[Optional[str], Optional[int]]:
     """Call the given command(s)."""
     assert isinstance(commands, list)
     process = None
+
+    popen_kwargs: Dict[str, Any] = {}
+    if sys.platform == "win32":
+        # This hides the console window if pythonw.exe is used
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        popen_kwargs["startupinfo"] = startupinfo
+
     for command in commands:
         try:
             dispcmd = str([command] + args)
@@ -80,10 +103,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
             process = subprocess.Popen([command] + args, cwd=cwd, env=env,
                                        stdout=subprocess.PIPE,
                                        stderr=(subprocess.PIPE if hide_stderr
-                                               else None))
+                                               else None), **popen_kwargs)
             break
-        except EnvironmentError:
-            e = sys.exc_info()[1]
+        except OSError as e:
             if e.errno == errno.ENOENT:
                 continue
             if verbose:
@@ -103,7 +125,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
     return stdout, process.returncode
 
 
-def versions_from_parentdir(parentdir_prefix, root, verbose):
+def versions_from_parentdir(
+    parentdir_prefix: str,
+    root: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Try to determine the version from the parent directory name.
 
     Source tarballs conventionally unpack into a directory that includes both
@@ -128,13 +154,13 @@ def versions_from_parentdir(parentdir_prefix, root, verbose):
 
 
 @register_vcs_handler("git", "get_keywords")
-def git_get_keywords(versionfile_abs):
+def git_get_keywords(versionfile_abs: str) -> Dict[str, str]:
     """Extract version information from the given file."""
     # the code embedded in _version.py can just fetch the value of these
     # keywords. When used from setup.py, we don't want to import _version.py,
     # so we do it with a regexp instead. This function is not used from
     # _version.py.
-    keywords = {}
+    keywords: Dict[str, str] = {}
     try:
         with open(versionfile_abs, "r") as fobj:
             for line in fobj:
@@ -150,13 +176,17 @@ def git_get_keywords(versionfile_abs):
                     mo = re.search(r'=\s*"(.*)"', line)
                     if mo:
                         keywords["date"] = mo.group(1)
-    except EnvironmentError:
+    except OSError:
         pass
     return keywords
 
 
 @register_vcs_handler("git", "keywords")
-def git_versions_from_keywords(keywords, tag_prefix, verbose):
+def git_versions_from_keywords(
+    keywords: Dict[str, str],
+    tag_prefix: str,
+    verbose: bool,
+) -> Dict[str, Any]:
     """Get version information from git keywords."""
     if "refnames" not in keywords:
         raise NotThisMethod("Short version file found")
@@ -220,7 +250,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose):
 
 
 @register_vcs_handler("git", "pieces_from_vcs")
-def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
+def git_pieces_from_vcs(
+    tag_prefix: str,
+    root: str,
+    verbose: bool,
+    runner: Callable = run_command
+) -> Dict[str, Any]:
     """Get version from 'git describe' in the root of the source tree.
 
     This only gets called if the git-archive 'subst' keywords were *not*
@@ -231,8 +266,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     if sys.platform == "win32":
         GITS = ["git.cmd", "git.exe"]
 
+    # GIT_DIR can interfere with correct operation of Versioneer.
+    # It may be intended to be passed to the Versioneer-versioned project,
+    # but that should not change where we get our version from.
+    env = os.environ.copy()
+    env.pop("GIT_DIR", None)
+    runner = functools.partial(runner, env=env)
+
     _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root,
-                   hide_stderr=True)
+                   hide_stderr=not verbose)
     if rc != 0:
         if verbose:
             print("Directory %s not under git control" % root)
@@ -240,10 +282,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
 
     # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
     # if there isn't one, this yields HEX[-dirty] (no NUM)
-    describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty",
-                                     "--always", "--long",
-                                     "--match", "%s*" % tag_prefix],
-                              cwd=root)
+    describe_out, rc = runner(GITS, [
+        "describe", "--tags", "--dirty", "--always", "--long",
+        "--match", f"{tag_prefix}[[:digit:]]*"
+    ], cwd=root)
     # --long was added in git-1.5.5
     if describe_out is None:
         raise NotThisMethod("'git describe' failed")
@@ -253,7 +295,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
         raise NotThisMethod("'git rev-parse' failed")
     full_out = full_out.strip()
 
-    pieces = {}
+    pieces: Dict[str, Any] = {}
     pieces["long"] = full_out
     pieces["short"] = full_out[:7]  # maybe improved later
     pieces["error"] = None
@@ -307,7 +349,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
         # TAG-NUM-gHEX
         mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
         if not mo:
-            # unparseable. Maybe git-describe is misbehaving?
+            # unparsable. Maybe git-describe is misbehaving?
             pieces["error"] = ("unable to parse git-describe output: '%s'"
                                % describe_out)
             return pieces
@@ -332,8 +374,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     else:
         # HEX: no tags
         pieces["closest-tag"] = None
-        count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root)
-        pieces["distance"] = int(count_out)  # total number of commits
+        out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root)
+        pieces["distance"] = len(out.split())  # total number of commits
 
     # commit date: see ISO-8601 comment in git_versions_from_keywords()
     date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip()
@@ -345,14 +387,14 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command):
     return pieces
 
 
-def plus_or_dot(pieces):
+def plus_or_dot(pieces: Dict[str, Any]) -> str:
     """Return a + if we don't already have one, else return a ."""
     if "+" in pieces.get("closest-tag", ""):
         return "."
     return "+"
 
 
-def render_pep440(pieces):
+def render_pep440(pieces: Dict[str, Any]) -> str:
     """Build up version string, with post-release "local version identifier".
 
     Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
@@ -377,7 +419,7 @@ def render_pep440(pieces):
     return rendered
 
 
-def render_pep440_branch(pieces):
+def render_pep440_branch(pieces: Dict[str, Any]) -> str:
     """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] .
 
     The ".dev0" means not master branch. Note that .dev0 sorts backwards
@@ -407,23 +449,41 @@ def render_pep440_branch(pieces):
     return rendered
 
 
-def render_pep440_pre(pieces):
-    """TAG[.post0.devDISTANCE] -- No -dirty.
+def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]:
+    """Split pep440 version string at the post-release segment.
+
+    Returns the release segments before the post-release and the
+    post-release version number (or -1 if no post-release segment is present).
+    """
+    vc = str.split(ver, ".post")
+    return vc[0], int(vc[1] or 0) if len(vc) == 2 else None
+
+
+def render_pep440_pre(pieces: Dict[str, Any]) -> str:
+    """TAG[.postN.devDISTANCE] -- No -dirty.
 
     Exceptions:
     1: no tags. 0.post0.devDISTANCE
     """
     if pieces["closest-tag"]:
-        rendered = pieces["closest-tag"]
         if pieces["distance"]:
-            rendered += ".post0.dev%d" % pieces["distance"]
+            # update the post release segment
+            tag_version, post_version = pep440_split_post(pieces["closest-tag"])
+            rendered = tag_version
+            if post_version is not None:
+                rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"])
+            else:
+                rendered += ".post0.dev%d" % (pieces["distance"])
+        else:
+            # no commits, use the tag as the version
+            rendered = pieces["closest-tag"]
     else:
         # exception #1
         rendered = "0.post0.dev%d" % pieces["distance"]
     return rendered
 
 
-def render_pep440_post(pieces):
+def render_pep440_post(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX] .
 
     The ".dev0" means dirty. Note that .dev0 sorts backwards
@@ -450,7 +510,7 @@ def render_pep440_post(pieces):
     return rendered
 
 
-def render_pep440_post_branch(pieces):
+def render_pep440_post_branch(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] .
 
     The ".dev0" means not master branch.
@@ -479,7 +539,7 @@ def render_pep440_post_branch(pieces):
     return rendered
 
 
-def render_pep440_old(pieces):
+def render_pep440_old(pieces: Dict[str, Any]) -> str:
     """TAG[.postDISTANCE[.dev0]] .
 
     The ".dev0" means dirty.
@@ -501,7 +561,7 @@ def render_pep440_old(pieces):
     return rendered
 
 
-def render_git_describe(pieces):
+def render_git_describe(pieces: Dict[str, Any]) -> str:
     """TAG[-DISTANCE-gHEX][-dirty].
 
     Like 'git describe --tags --dirty --always'.
@@ -521,7 +581,7 @@ def render_git_describe(pieces):
     return rendered
 
 
-def render_git_describe_long(pieces):
+def render_git_describe_long(pieces: Dict[str, Any]) -> str:
     """TAG-DISTANCE-gHEX[-dirty].
 
     Like 'git describe --tags --dirty --always -long'.
@@ -541,7 +601,7 @@ def render_git_describe_long(pieces):
     return rendered
 
 
-def render(pieces, style):
+def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]:
     """Render the given version pieces into the requested style."""
     if pieces["error"]:
         return {"version": "unknown",
@@ -577,7 +637,7 @@ def render(pieces, style):
             "date": pieces.get("date")}
 
 
-def get_versions():
+def get_versions() -> Dict[str, Any]:
     """Get version information or return default if unable to do so."""
     # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
     # __file__, we can work backwards from there to the root. Some
diff --git a/cuda/tests/__init__.py b/cuda/cuda/bindings/benchmarks/__init__.py
similarity index 100%
rename from cuda/tests/__init__.py
rename to cuda/cuda/bindings/benchmarks/__init__.py
diff --git a/cuda/benchmarks/kernels.py b/cuda/cuda/bindings/benchmarks/kernels.py
similarity index 100%
rename from cuda/benchmarks/kernels.py
rename to cuda/cuda/bindings/benchmarks/kernels.py
diff --git a/cuda/benchmarks/perf_test_utils.py b/cuda/cuda/bindings/benchmarks/perf_test_utils.py
similarity index 100%
rename from cuda/benchmarks/perf_test_utils.py
rename to cuda/cuda/bindings/benchmarks/perf_test_utils.py
diff --git a/cuda/benchmarks/test_cupy.py b/cuda/cuda/bindings/benchmarks/test_cupy.py
similarity index 100%
rename from cuda/benchmarks/test_cupy.py
rename to cuda/cuda/bindings/benchmarks/test_cupy.py
diff --git a/cuda/benchmarks/test_launch_latency.py b/cuda/cuda/bindings/benchmarks/test_launch_latency.py
similarity index 100%
rename from cuda/benchmarks/test_launch_latency.py
rename to cuda/cuda/bindings/benchmarks/test_launch_latency.py
diff --git a/cuda/benchmarks/test_numba.py b/cuda/cuda/bindings/benchmarks/test_numba.py
similarity index 100%
rename from cuda/benchmarks/test_numba.py
rename to cuda/cuda/bindings/benchmarks/test_numba.py
diff --git a/cuda/benchmarks/test_pointer_attributes.py b/cuda/cuda/bindings/benchmarks/test_pointer_attributes.py
similarity index 100%
rename from cuda/benchmarks/test_pointer_attributes.py
rename to cuda/cuda/bindings/benchmarks/test_pointer_attributes.py
diff --git a/cuda/ccuda.pxd.in b/cuda/cuda/bindings/cydriver.pxd.in
similarity index 94%
rename from cuda/ccuda.pxd.in
rename to cuda/cuda/bindings/cydriver.pxd.in
index 0b20da8c..d86ed1ce 100644
--- a/cuda/ccuda.pxd.in
+++ b/cuda/cuda/bindings/cydriver.pxd.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -210,10 +210,10 @@ cdef extern from "cuda.h":
     cdef enum CUstreamBatchMemOpType_enum:
         CU_STREAM_MEM_OP_WAIT_VALUE_32 = 1
         CU_STREAM_MEM_OP_WRITE_VALUE_32 = 2
+        CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3
         CU_STREAM_MEM_OP_WAIT_VALUE_64 = 4
         CU_STREAM_MEM_OP_WRITE_VALUE_64 = 5
         CU_STREAM_MEM_OP_BARRIER = 6
-        CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = 3
 
     ctypedef CUstreamBatchMemOpType_enum CUstreamBatchMemOpType
 
@@ -226,6 +226,7 @@ cdef extern from "cuda.h":
     cdef struct CUstreamMemOpWaitValueParams_st:
         CUstreamBatchMemOpType operation
         CUdeviceptr address
+        cuuint32_t value
         cuuint64_t value64
         unsigned int flags
         CUdeviceptr alias
@@ -233,6 +234,7 @@ cdef extern from "cuda.h":
     cdef struct CUstreamMemOpWriteValueParams_st:
         CUstreamBatchMemOpType operation
         CUdeviceptr address
+        cuuint32_t value
         cuuint64_t value64
         unsigned int flags
         CUdeviceptr alias
@@ -286,19 +288,6 @@ cdef extern from "cuda.h":
         CU_AD_FORMAT_SIGNED_INT32 = 10
         CU_AD_FORMAT_HALF = 16
         CU_AD_FORMAT_FLOAT = 32
-        CU_AD_FORMAT_NV12 = 176
-        CU_AD_FORMAT_UNORM_INT8X1 = 192
-        CU_AD_FORMAT_UNORM_INT8X2 = 193
-        CU_AD_FORMAT_UNORM_INT8X4 = 194
-        CU_AD_FORMAT_UNORM_INT16X1 = 195
-        CU_AD_FORMAT_UNORM_INT16X2 = 196
-        CU_AD_FORMAT_UNORM_INT16X4 = 197
-        CU_AD_FORMAT_SNORM_INT8X1 = 198
-        CU_AD_FORMAT_SNORM_INT8X2 = 199
-        CU_AD_FORMAT_SNORM_INT8X4 = 200
-        CU_AD_FORMAT_SNORM_INT16X1 = 201
-        CU_AD_FORMAT_SNORM_INT16X2 = 202
-        CU_AD_FORMAT_SNORM_INT16X4 = 203
         CU_AD_FORMAT_BC1_UNORM = 145
         CU_AD_FORMAT_BC1_UNORM_SRGB = 146
         CU_AD_FORMAT_BC2_UNORM = 147
@@ -313,6 +302,19 @@ cdef extern from "cuda.h":
         CU_AD_FORMAT_BC6H_SF16 = 156
         CU_AD_FORMAT_BC7_UNORM = 157
         CU_AD_FORMAT_BC7_UNORM_SRGB = 158
+        CU_AD_FORMAT_NV12 = 176
+        CU_AD_FORMAT_UNORM_INT8X1 = 192
+        CU_AD_FORMAT_UNORM_INT8X2 = 193
+        CU_AD_FORMAT_UNORM_INT8X4 = 194
+        CU_AD_FORMAT_UNORM_INT16X1 = 195
+        CU_AD_FORMAT_UNORM_INT16X2 = 196
+        CU_AD_FORMAT_UNORM_INT16X4 = 197
+        CU_AD_FORMAT_SNORM_INT8X1 = 198
+        CU_AD_FORMAT_SNORM_INT8X2 = 199
+        CU_AD_FORMAT_SNORM_INT8X4 = 200
+        CU_AD_FORMAT_SNORM_INT16X1 = 201
+        CU_AD_FORMAT_SNORM_INT16X2 = 202
+        CU_AD_FORMAT_SNORM_INT16X4 = 203
 
     ctypedef CUarray_format_enum CUarray_format
 
@@ -360,10 +362,10 @@ cdef extern from "cuda.h":
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = 25
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = 26
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = 27
-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28
-        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = 27
+        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = 28
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = 28
+        CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = 29
         CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = 29
         CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = 30
         CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = 31
@@ -543,8 +545,8 @@ cdef extern from "cuda.h":
 
     cdef enum CUshared_carveout_enum:
         CU_SHAREDMEM_CARVEOUT_DEFAULT = -1
-        CU_SHAREDMEM_CARVEOUT_MAX_SHARED = 100
         CU_SHAREDMEM_CARVEOUT_MAX_L1 = 0
+        CU_SHAREDMEM_CARVEOUT_MAX_SHARED = 100
 
     ctypedef CUshared_carveout_enum CUshared_carveout
 
@@ -815,12 +817,12 @@ cdef extern from "cuda.h":
 
     ctypedef CUlaunchAttributeID_enum CUlaunchAttributeID
 
-    cdef struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s:
+    cdef struct anon_struct0:
         unsigned int x
         unsigned int y
         unsigned int z
 
-    cdef struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s:
+    cdef struct anon_struct1:
         CUevent event
         int flags
         int triggerAtBlockStart
@@ -830,10 +832,10 @@ cdef extern from "cuda.h":
         CUaccessPolicyWindow accessPolicyWindow
         int cooperative
         CUsynchronizationPolicy syncPolicy
-        _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s clusterDim
+        anon_struct0 clusterDim
         CUclusterSchedulingPolicy clusterSchedulingPolicyPreference
         int programmaticStreamSerializationAllowed
-        _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s programmaticEvent
+        anon_struct1 programmaticEvent
         int priority
 
     ctypedef CUlaunchAttributeValue_union CUlaunchAttributeValue
@@ -904,12 +906,12 @@ cdef extern from "cuda.h":
 
     ctypedef CUexecAffinitySmCount_v1 CUexecAffinitySmCount
 
-    cdef union _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u:
+    cdef union anon_union2:
         CUexecAffinitySmCount smCount
 
     cdef struct CUexecAffinityParam_st:
         CUexecAffinityType type
-        _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u param
+        anon_union2 param
 
     ctypedef CUexecAffinityParam_st CUexecAffinityParam_v1
 
@@ -1128,13 +1130,13 @@ cdef extern from "cuda.h":
 
     ctypedef CUDA_ARRAY3D_DESCRIPTOR_v2 CUDA_ARRAY3D_DESCRIPTOR
 
-    cdef struct _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s:
+    cdef struct anon_struct2:
         unsigned int width
         unsigned int height
         unsigned int depth
 
     cdef struct CUDA_ARRAY_SPARSE_PROPERTIES_st:
-        _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s tileExtent
+        anon_struct2 tileExtent
         unsigned int miptailFirstLevel
         unsigned long long miptailSize
         unsigned int flags
@@ -1153,19 +1155,19 @@ cdef extern from "cuda.h":
 
     ctypedef CUDA_ARRAY_MEMORY_REQUIREMENTS_v1 CUDA_ARRAY_MEMORY_REQUIREMENTS
 
-    cdef struct _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s:
+    cdef struct anon_struct3:
         CUarray hArray
 
-    cdef struct _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s:
+    cdef struct anon_struct4:
         CUmipmappedArray hMipmappedArray
 
-    cdef struct _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s:
+    cdef struct anon_struct5:
         CUdeviceptr devPtr
         CUarray_format format
         unsigned int numChannels
         size_t sizeInBytes
 
-    cdef struct _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s:
+    cdef struct anon_struct6:
         CUdeviceptr devPtr
         CUarray_format format
         unsigned int numChannels
@@ -1173,19 +1175,19 @@ cdef extern from "cuda.h":
         size_t height
         size_t pitchInBytes
 
-    cdef struct _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s:
+    cdef struct anon_struct7:
         int reserved[32]
 
-    cdef union _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u:
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s array
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s mipmap
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s linear
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s pitch2D
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s reserved
+    cdef union anon_union3:
+        anon_struct3 array
+        anon_struct4 mipmap
+        anon_struct5 linear
+        anon_struct6 pitch2D
+        anon_struct7 reserved
 
     cdef struct CUDA_RESOURCE_DESC_st:
         CUresourcetype resType
-        _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u res
+        anon_union3 res
         unsigned int flags
 
     ctypedef CUDA_RESOURCE_DESC_st CUDA_RESOURCE_DESC_v1
@@ -1305,18 +1307,18 @@ cdef extern from "cuda.h":
 
     ctypedef CUexternalMemoryHandleType_enum CUexternalMemoryHandleType
 
-    cdef struct _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s:
+    cdef struct anon_struct8:
         void* handle
         const void* name
 
-    cdef union _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u:
+    cdef union anon_union4:
         int fd
-        _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s win32
+        anon_struct8 win32
         const void* nvSciBufObject
 
     cdef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
         CUexternalMemoryHandleType type
-        _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u handle
+        anon_union4 handle
         unsigned long long size
         unsigned int flags
         unsigned int reserved[16]
@@ -1359,18 +1361,18 @@ cdef extern from "cuda.h":
 
     ctypedef CUexternalSemaphoreHandleType_enum CUexternalSemaphoreHandleType
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s:
+    cdef struct anon_struct9:
         void* handle
         const void* name
 
-    cdef union _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u:
+    cdef union anon_union5:
         int fd
-        _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s win32
+        anon_struct9 win32
         const void* nvSciSyncObj
 
     cdef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
         CUexternalSemaphoreHandleType type
-        _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u handle
+        anon_union5 handle
         unsigned int flags
         unsigned int reserved[16]
 
@@ -1378,24 +1380,24 @@ cdef extern from "cuda.h":
 
     ctypedef CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1 CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s:
+    cdef struct anon_struct10:
         unsigned long long value
 
-    cdef union _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u:
+    cdef union anon_union6:
         void* fence
         unsigned long long reserved
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s:
+    cdef struct anon_struct11:
         unsigned long long key
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s:
-        _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s fence
-        _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u nvSciSync
-        _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s keyedMutex
+    cdef struct anon_struct12:
+        anon_struct10 fence
+        anon_union6 nvSciSync
+        anon_struct11 keyedMutex
         unsigned int reserved[12]
 
     cdef struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
-        _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s params
+        anon_struct12 params
         unsigned int flags
         unsigned int reserved[16]
 
@@ -1403,25 +1405,25 @@ cdef extern from "cuda.h":
 
     ctypedef CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1 CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s:
+    cdef struct anon_struct13:
         unsigned long long value
 
-    cdef union _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u:
+    cdef union anon_union7:
         void* fence
         unsigned long long reserved
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s:
+    cdef struct anon_struct14:
         unsigned long long key
         unsigned int timeoutMs
 
-    cdef struct _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s:
-        _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s fence
-        _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u nvSciSync
-        _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s keyedMutex
+    cdef struct anon_struct15:
+        anon_struct13 fence
+        anon_union7 nvSciSync
+        anon_struct14 keyedMutex
         unsigned int reserved[10]
 
     cdef struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
-        _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s params
+        anon_struct15 params
         unsigned int flags
         unsigned int reserved[16]
 
@@ -1511,11 +1513,11 @@ cdef extern from "cuda.h":
 
     ctypedef CUmemHandleType_enum CUmemHandleType
 
-    cdef union _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u:
+    cdef union anon_union8:
         CUmipmappedArray mipmap
         CUarray array
 
-    cdef struct _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s:
+    cdef struct anon_struct16:
         unsigned int level
         unsigned int layer
         unsigned int offsetX
@@ -1525,26 +1527,26 @@ cdef extern from "cuda.h":
         unsigned int extentHeight
         unsigned int extentDepth
 
-    cdef struct _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s:
+    cdef struct anon_struct17:
         unsigned int layer
         unsigned long long offset
         unsigned long long size
 
-    cdef union _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u:
-        _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s sparseLevel
-        _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s miptail
+    cdef union anon_union9:
+        anon_struct16 sparseLevel
+        anon_struct17 miptail
 
-    cdef union _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u:
+    cdef union anon_union10:
         CUmemGenericAllocationHandle memHandle
 
     cdef struct CUarrayMapInfo_st:
         CUresourcetype resourceType
-        _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u resource
+        anon_union8 resource
         CUarraySparseSubresourceType subresourceType
-        _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u subresource
+        anon_union9 subresource
         CUmemOperationType memOperationType
         CUmemHandleType memHandleType
-        _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u memHandle
+        anon_union10 memHandle
         unsigned long long offset
         unsigned int deviceBitMask
         unsigned int flags
@@ -1568,7 +1570,7 @@ cdef extern from "cuda.h":
 
     ctypedef CUmemAllocationCompType_enum CUmemAllocationCompType
 
-    cdef struct _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s:
+    cdef struct anon_struct18:
         unsigned char compressionType
         unsigned char gpuDirectRDMACapable
         unsigned short usage
@@ -1579,7 +1581,7 @@ cdef extern from "cuda.h":
         CUmemAllocationHandleType requestedHandleTypes
         CUmemLocation location
         void* win32HandleMetaData
-        _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s allocFlags
+        anon_struct18 allocFlags
 
     ctypedef CUmemAllocationProp_st CUmemAllocationProp_v1
 
@@ -1717,6 +1719,213 @@ cdef extern from "cuda.h":
 
     ctypedef CUmoduleLoadingMode_enum CUmoduleLoadingMode
 
+cdef extern from "cudaProfiler.h":
+
+    cdef enum CUoutput_mode_enum:
+        CU_OUT_KEY_VALUE_PAIR = 0
+        CU_OUT_CSV = 1
+
+    ctypedef CUoutput_mode_enum CUoutput_mode
+
+cdef enum CUeglFrameType_enum:
+    CU_EGL_FRAME_TYPE_ARRAY = 0
+    CU_EGL_FRAME_TYPE_PITCH = 1
+
+ctypedef CUeglFrameType_enum CUeglFrameType
+
+cdef enum CUeglResourceLocationFlags_enum:
+    CU_EGL_RESOURCE_LOCATION_SYSMEM = 0
+    CU_EGL_RESOURCE_LOCATION_VIDMEM = 1
+
+ctypedef CUeglResourceLocationFlags_enum CUeglResourceLocationFlags
+
+cdef enum CUeglColorFormat_enum:
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR = 0
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR = 1
+    CU_EGL_COLOR_FORMAT_YUV422_PLANAR = 2
+    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR = 3
+    CU_EGL_COLOR_FORMAT_RGB = 4
+    CU_EGL_COLOR_FORMAT_BGR = 5
+    CU_EGL_COLOR_FORMAT_ARGB = 6
+    CU_EGL_COLOR_FORMAT_RGBA = 7
+    CU_EGL_COLOR_FORMAT_L = 8
+    CU_EGL_COLOR_FORMAT_R = 9
+    CU_EGL_COLOR_FORMAT_YUV444_PLANAR = 10
+    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR = 11
+    CU_EGL_COLOR_FORMAT_YUYV_422 = 12
+    CU_EGL_COLOR_FORMAT_UYVY_422 = 13
+    CU_EGL_COLOR_FORMAT_ABGR = 14
+    CU_EGL_COLOR_FORMAT_BGRA = 15
+    CU_EGL_COLOR_FORMAT_A = 16
+    CU_EGL_COLOR_FORMAT_RG = 17
+    CU_EGL_COLOR_FORMAT_AYUV = 18
+    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR = 19
+    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR = 20
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR = 21
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR = 22
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR = 23
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR = 24
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR = 25
+    CU_EGL_COLOR_FORMAT_VYUY_ER = 26
+    CU_EGL_COLOR_FORMAT_UYVY_ER = 27
+    CU_EGL_COLOR_FORMAT_YUYV_ER = 28
+    CU_EGL_COLOR_FORMAT_YVYU_ER = 29
+    CU_EGL_COLOR_FORMAT_YUV_ER = 30
+    CU_EGL_COLOR_FORMAT_YUVA_ER = 31
+    CU_EGL_COLOR_FORMAT_AYUV_ER = 32
+    CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER = 33
+    CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER = 34
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER = 35
+    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER = 36
+    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER = 37
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER = 38
+    CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER = 39
+    CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER = 40
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER = 41
+    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER = 42
+    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER = 43
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER = 44
+    CU_EGL_COLOR_FORMAT_BAYER_RGGB = 45
+    CU_EGL_COLOR_FORMAT_BAYER_BGGR = 46
+    CU_EGL_COLOR_FORMAT_BAYER_GRBG = 47
+    CU_EGL_COLOR_FORMAT_BAYER_GBRG = 48
+    CU_EGL_COLOR_FORMAT_BAYER10_RGGB = 49
+    CU_EGL_COLOR_FORMAT_BAYER10_BGGR = 50
+    CU_EGL_COLOR_FORMAT_BAYER10_GRBG = 51
+    CU_EGL_COLOR_FORMAT_BAYER10_GBRG = 52
+    CU_EGL_COLOR_FORMAT_BAYER12_RGGB = 53
+    CU_EGL_COLOR_FORMAT_BAYER12_BGGR = 54
+    CU_EGL_COLOR_FORMAT_BAYER12_GRBG = 55
+    CU_EGL_COLOR_FORMAT_BAYER12_GBRG = 56
+    CU_EGL_COLOR_FORMAT_BAYER14_RGGB = 57
+    CU_EGL_COLOR_FORMAT_BAYER14_BGGR = 58
+    CU_EGL_COLOR_FORMAT_BAYER14_GRBG = 59
+    CU_EGL_COLOR_FORMAT_BAYER14_GBRG = 60
+    CU_EGL_COLOR_FORMAT_BAYER20_RGGB = 61
+    CU_EGL_COLOR_FORMAT_BAYER20_BGGR = 62
+    CU_EGL_COLOR_FORMAT_BAYER20_GRBG = 63
+    CU_EGL_COLOR_FORMAT_BAYER20_GBRG = 64
+    CU_EGL_COLOR_FORMAT_YVU444_PLANAR = 65
+    CU_EGL_COLOR_FORMAT_YVU422_PLANAR = 66
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR = 67
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB = 68
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR = 69
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG = 70
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG = 71
+    CU_EGL_COLOR_FORMAT_BAYER_BCCR = 72
+    CU_EGL_COLOR_FORMAT_BAYER_RCCB = 73
+    CU_EGL_COLOR_FORMAT_BAYER_CRBC = 74
+    CU_EGL_COLOR_FORMAT_BAYER_CBRC = 75
+    CU_EGL_COLOR_FORMAT_BAYER10_CCCC = 76
+    CU_EGL_COLOR_FORMAT_BAYER12_BCCR = 77
+    CU_EGL_COLOR_FORMAT_BAYER12_RCCB = 78
+    CU_EGL_COLOR_FORMAT_BAYER12_CRBC = 79
+    CU_EGL_COLOR_FORMAT_BAYER12_CBRC = 80
+    CU_EGL_COLOR_FORMAT_BAYER12_CCCC = 81
+    CU_EGL_COLOR_FORMAT_Y = 82
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 = 83
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 = 84
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 = 85
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 = 86
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 = 87
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 = 88
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 = 89
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 = 90
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 = 91
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 = 92
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 = 93
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR = 94
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 = 95
+    CU_EGL_COLOR_FORMAT_Y_ER = 96
+    CU_EGL_COLOR_FORMAT_Y_709_ER = 97
+    CU_EGL_COLOR_FORMAT_Y10_ER = 98
+    CU_EGL_COLOR_FORMAT_Y10_709_ER = 99
+    CU_EGL_COLOR_FORMAT_Y12_ER = 100
+    CU_EGL_COLOR_FORMAT_Y12_709_ER = 101
+    CU_EGL_COLOR_FORMAT_YUVA = 102
+    CU_EGL_COLOR_FORMAT_YUV = 103
+    CU_EGL_COLOR_FORMAT_YVYU = 104
+    CU_EGL_COLOR_FORMAT_VYUY = 105
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER = 106
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER = 107
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER = 108
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER = 109
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER = 110
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER = 111
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER = 112
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER = 113
+    CU_EGL_COLOR_FORMAT_MAX = 114
+
+ctypedef CUeglColorFormat_enum CUeglColorFormat
+
+cdef union anon_union11:
+    CUarray pArray[3]
+    void* pPitch[3]
+
+cdef struct CUeglFrame_st:
+    anon_union11 frame
+    unsigned int width
+    unsigned int height
+    unsigned int depth
+    unsigned int pitch
+    unsigned int planeCount
+    unsigned int numChannels
+    CUeglFrameType frameType
+    CUeglColorFormat eglColorFormat
+    CUarray_format cuFormat
+
+ctypedef CUeglFrame_st CUeglFrame_v1
+
+ctypedef CUeglFrame_v1 CUeglFrame
+
+cdef extern from "":
+    cdef struct CUeglStreamConnection_st:
+        pass
+ctypedef CUeglStreamConnection_st* CUeglStreamConnection
+
+cdef enum CUGLDeviceList_enum:
+    CU_GL_DEVICE_LIST_ALL = 1
+    CU_GL_DEVICE_LIST_CURRENT_FRAME = 2
+    CU_GL_DEVICE_LIST_NEXT_FRAME = 3
+
+ctypedef CUGLDeviceList_enum CUGLDeviceList
+
+cdef enum CUGLmap_flags_enum:
+    CU_GL_MAP_RESOURCE_FLAGS_NONE = 0
+    CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = 1
+    CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 2
+
+ctypedef CUGLmap_flags_enum CUGLmap_flags
+
+ctypedef unsigned int GLenum
+
+ctypedef unsigned int GLuint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLImageKHR
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLStreamKHR
+
+ctypedef unsigned int EGLint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLSyncKHR
+
+ctypedef uint32_t VdpDevice
+
+ctypedef unsigned long long VdpGetProcAddress
+
+ctypedef uint32_t VdpVideoSurface
+
+ctypedef uint32_t VdpOutputSurface
+
 {{if 'cuGetErrorString' in found_functions}}
 
 cdef CUresult cuGetErrorString(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil
@@ -3557,14 +3766,6 @@ cdef CUresult cuGetProcAddress(const char* symbol, void** pfn, int cudaVersion,
 cdef CUresult cuGetExportTable(const void** ppExportTable, const CUuuid* pExportTableId) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-cdef extern from "cudaProfiler.h":
-
-    cdef enum CUoutput_mode_enum:
-        CU_OUT_KEY_VALUE_PAIR = 0
-        CU_OUT_CSV = 1
-
-    ctypedef CUoutput_mode_enum CUoutput_mode
-
 {{if 'cuProfilerInitialize' in found_functions}}
 
 cdef CUresult cuProfilerInitialize(const char* configFile, const char* outputFile, CUoutput_mode outputMode) except ?CUDA_ERROR_NOT_FOUND nogil
@@ -3580,303 +3781,99 @@ cdef CUresult cuProfilerStart() except ?CUDA_ERROR_NOT_FOUND nogil
 cdef CUresult cuProfilerStop() except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-from libc.stdint cimport uint32_t
-
-
-ctypedef unsigned int GLenum
-
-ctypedef unsigned int GLuint
-
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLImageKHR
-
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLStreamKHR
-
-ctypedef unsigned int EGLint
-
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLSyncKHR
-
-ctypedef uint32_t VdpDevice
-
-ctypedef unsigned long long VdpGetProcAddress
-
-ctypedef uint32_t VdpVideoSurface
-
-ctypedef uint32_t VdpOutputSurface
-
-{{if True or 'cuVDPAUGetDevice' in found_functions}}
-
-cdef CUresult cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-
-cdef CUresult cuVDPAUCtxCreate(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
-{{endif}}
-
-
-cdef enum CUeglFrameType_enum:
-    CU_EGL_FRAME_TYPE_ARRAY = 0
-    CU_EGL_FRAME_TYPE_PITCH = 1
-
-ctypedef CUeglFrameType_enum CUeglFrameType
-
-cdef enum CUeglResourceLocationFlags_enum:
-    CU_EGL_RESOURCE_LOCATION_SYSMEM = 0
-    CU_EGL_RESOURCE_LOCATION_VIDMEM = 1
-
-ctypedef CUeglResourceLocationFlags_enum CUeglResourceLocationFlags
-
-cdef enum CUeglColorFormat_enum:
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR = 0
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR = 1
-    CU_EGL_COLOR_FORMAT_YUV422_PLANAR = 2
-    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR = 3
-    CU_EGL_COLOR_FORMAT_RGB = 4
-    CU_EGL_COLOR_FORMAT_BGR = 5
-    CU_EGL_COLOR_FORMAT_ARGB = 6
-    CU_EGL_COLOR_FORMAT_RGBA = 7
-    CU_EGL_COLOR_FORMAT_L = 8
-    CU_EGL_COLOR_FORMAT_R = 9
-    CU_EGL_COLOR_FORMAT_YUV444_PLANAR = 10
-    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR = 11
-    CU_EGL_COLOR_FORMAT_YUYV_422 = 12
-    CU_EGL_COLOR_FORMAT_UYVY_422 = 13
-    CU_EGL_COLOR_FORMAT_ABGR = 14
-    CU_EGL_COLOR_FORMAT_BGRA = 15
-    CU_EGL_COLOR_FORMAT_A = 16
-    CU_EGL_COLOR_FORMAT_RG = 17
-    CU_EGL_COLOR_FORMAT_AYUV = 18
-    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR = 19
-    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR = 20
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR = 21
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR = 22
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR = 23
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR = 24
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR = 25
-    CU_EGL_COLOR_FORMAT_VYUY_ER = 26
-    CU_EGL_COLOR_FORMAT_UYVY_ER = 27
-    CU_EGL_COLOR_FORMAT_YUYV_ER = 28
-    CU_EGL_COLOR_FORMAT_YVYU_ER = 29
-    CU_EGL_COLOR_FORMAT_YUV_ER = 30
-    CU_EGL_COLOR_FORMAT_YUVA_ER = 31
-    CU_EGL_COLOR_FORMAT_AYUV_ER = 32
-    CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER = 33
-    CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER = 34
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER = 35
-    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER = 36
-    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER = 37
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER = 38
-    CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER = 39
-    CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER = 40
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER = 41
-    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER = 42
-    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER = 43
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER = 44
-    CU_EGL_COLOR_FORMAT_BAYER_RGGB = 45
-    CU_EGL_COLOR_FORMAT_BAYER_BGGR = 46
-    CU_EGL_COLOR_FORMAT_BAYER_GRBG = 47
-    CU_EGL_COLOR_FORMAT_BAYER_GBRG = 48
-    CU_EGL_COLOR_FORMAT_BAYER10_RGGB = 49
-    CU_EGL_COLOR_FORMAT_BAYER10_BGGR = 50
-    CU_EGL_COLOR_FORMAT_BAYER10_GRBG = 51
-    CU_EGL_COLOR_FORMAT_BAYER10_GBRG = 52
-    CU_EGL_COLOR_FORMAT_BAYER12_RGGB = 53
-    CU_EGL_COLOR_FORMAT_BAYER12_BGGR = 54
-    CU_EGL_COLOR_FORMAT_BAYER12_GRBG = 55
-    CU_EGL_COLOR_FORMAT_BAYER12_GBRG = 56
-    CU_EGL_COLOR_FORMAT_BAYER14_RGGB = 57
-    CU_EGL_COLOR_FORMAT_BAYER14_BGGR = 58
-    CU_EGL_COLOR_FORMAT_BAYER14_GRBG = 59
-    CU_EGL_COLOR_FORMAT_BAYER14_GBRG = 60
-    CU_EGL_COLOR_FORMAT_BAYER20_RGGB = 61
-    CU_EGL_COLOR_FORMAT_BAYER20_BGGR = 62
-    CU_EGL_COLOR_FORMAT_BAYER20_GRBG = 63
-    CU_EGL_COLOR_FORMAT_BAYER20_GBRG = 64
-    CU_EGL_COLOR_FORMAT_YVU444_PLANAR = 65
-    CU_EGL_COLOR_FORMAT_YVU422_PLANAR = 66
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR = 67
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB = 68
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR = 69
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG = 70
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG = 71
-    CU_EGL_COLOR_FORMAT_BAYER_BCCR = 72
-    CU_EGL_COLOR_FORMAT_BAYER_RCCB = 73
-    CU_EGL_COLOR_FORMAT_BAYER_CRBC = 74
-    CU_EGL_COLOR_FORMAT_BAYER_CBRC = 75
-    CU_EGL_COLOR_FORMAT_BAYER10_CCCC = 76
-    CU_EGL_COLOR_FORMAT_BAYER12_BCCR = 77
-    CU_EGL_COLOR_FORMAT_BAYER12_RCCB = 78
-    CU_EGL_COLOR_FORMAT_BAYER12_CRBC = 79
-    CU_EGL_COLOR_FORMAT_BAYER12_CBRC = 80
-    CU_EGL_COLOR_FORMAT_BAYER12_CCCC = 81
-    CU_EGL_COLOR_FORMAT_Y = 82
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 = 83
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 = 84
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 = 85
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 = 86
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 = 87
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 = 88
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 = 89
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 = 90
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 = 91
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 = 92
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 = 93
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR = 94
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 = 95
-    CU_EGL_COLOR_FORMAT_Y_ER = 96
-    CU_EGL_COLOR_FORMAT_Y_709_ER = 97
-    CU_EGL_COLOR_FORMAT_Y10_ER = 98
-    CU_EGL_COLOR_FORMAT_Y10_709_ER = 99
-    CU_EGL_COLOR_FORMAT_Y12_ER = 100
-    CU_EGL_COLOR_FORMAT_Y12_709_ER = 101
-    CU_EGL_COLOR_FORMAT_YUVA = 102
-    CU_EGL_COLOR_FORMAT_YUV = 103
-    CU_EGL_COLOR_FORMAT_YVYU = 104
-    CU_EGL_COLOR_FORMAT_VYUY = 105
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER = 106
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER = 107
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER = 108
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER = 109
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER = 110
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER = 111
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER = 112
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER = 113
-    CU_EGL_COLOR_FORMAT_MAX = 114
-
-ctypedef CUeglColorFormat_enum CUeglColorFormat
-
-cdef union _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
-    CUarray pArray[3]
-    void* pPitch[3]
-
-cdef struct CUeglFrame_st:
-    _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u frame
-    unsigned int width
-    unsigned int height
-    unsigned int depth
-    unsigned int pitch
-    unsigned int planeCount
-    unsigned int numChannels
-    CUeglFrameType frameType
-    CUeglColorFormat eglColorFormat
-    CUarray_format cuFormat
-
-ctypedef CUeglFrame_st CUeglFrame_v1
-
-ctypedef CUeglFrame_v1 CUeglFrame
-
-cdef extern from "":
-    cdef struct CUeglStreamConnection_st:
-        pass
-ctypedef CUeglStreamConnection_st* CUeglStreamConnection
-
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGLImageKHR image, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn, EGLStreamKHR stream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgraphicsResource* pCudaResource, CUstream* pStream, unsigned int timeout) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgraphicsResource pCudaResource, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream, EGLint width, EGLint height) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraphicsResource resource, unsigned int index, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
+{{if True}}
 
-cdef enum CUGLDeviceList_enum:
-    CU_GL_DEVICE_LIST_ALL = 1
-    CU_GL_DEVICE_LIST_CURRENT_FRAME = 2
-    CU_GL_DEVICE_LIST_NEXT_FRAME = 3
+cdef CUresult cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
 
-ctypedef CUGLDeviceList_enum CUGLDeviceList
+{{if True}}
 
-cdef enum CUGLmap_flags_enum:
-    CU_GL_MAP_RESOURCE_FLAGS_NONE = 0
-    CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = 1
-    CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 2
+cdef CUresult cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
 
-ctypedef CUGLmap_flags_enum CUGLmap_flags
+{{if True}}
 
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+cdef CUresult cuGLGetDevices(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
 
-cdef CUresult cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{if True}}
+
+cdef CUresult cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+{{if True}}
 
-cdef CUresult cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil
+cdef CUresult cuVDPAUCtxCreate(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
-{{if True or 'cuGLGetDevices_v2' in found_functions}}
+{{if True}}
 
-cdef CUresult cuGLGetDevices(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil
+cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
+{{endif}}
+
+{{if True}}
+
+cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil
 {{endif}}
 
 cdef enum: CUDA_VERSION = 11080
@@ -3983,4 +3980,4 @@ cdef enum: CU_DEVICE_INVALID = -2
 
 cdef enum: MAX_PLANES = 3
 
-cdef enum: CUDA_EGL_INFINITE_TIMEOUT = 4294967295
+cdef enum: CUDA_EGL_INFINITE_TIMEOUT = 4294967295
\ No newline at end of file
diff --git a/cuda/ccuda.pyx.in b/cuda/cuda/bindings/cydriver.pyx.in
similarity index 73%
rename from cuda/ccuda.pyx.in
rename to cuda/cuda/bindings/cydriver.pyx.in
index 29ae3896..98a2282f 100644
--- a/cuda/ccuda.pyx.in
+++ b/cuda/cuda/bindings/cydriver.pyx.in
@@ -1,2348 +1,2348 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda._cuda.ccuda as ccuda
+cimport cuda.bindings._bindings.cydriver as cydriver
 
 {{if 'cuGetErrorString' in found_functions}}
 
 cdef CUresult cuGetErrorString(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGetErrorString(error, pStr)
+    return cydriver._cuGetErrorString(error, pStr)
 {{endif}}
 
 {{if 'cuGetErrorName' in found_functions}}
 
 cdef CUresult cuGetErrorName(CUresult error, const char** pStr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGetErrorName(error, pStr)
+    return cydriver._cuGetErrorName(error, pStr)
 {{endif}}
 
 {{if 'cuInit' in found_functions}}
 
 cdef CUresult cuInit(unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuInit(Flags)
+    return cydriver._cuInit(Flags)
 {{endif}}
 
 {{if 'cuDriverGetVersion' in found_functions}}
 
 cdef CUresult cuDriverGetVersion(int* driverVersion) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDriverGetVersion(driverVersion)
+    return cydriver._cuDriverGetVersion(driverVersion)
 {{endif}}
 
 {{if 'cuDeviceGet' in found_functions}}
 
 cdef CUresult cuDeviceGet(CUdevice* device, int ordinal) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGet(device, ordinal)
+    return cydriver._cuDeviceGet(device, ordinal)
 {{endif}}
 
 {{if 'cuDeviceGetCount' in found_functions}}
 
 cdef CUresult cuDeviceGetCount(int* count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetCount(count)
+    return cydriver._cuDeviceGetCount(count)
 {{endif}}
 
 {{if 'cuDeviceGetName' in found_functions}}
 
 cdef CUresult cuDeviceGetName(char* name, int length, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetName(name, length, dev)
+    return cydriver._cuDeviceGetName(name, length, dev)
 {{endif}}
 
 {{if 'cuDeviceGetUuid' in found_functions}}
 
 cdef CUresult cuDeviceGetUuid(CUuuid* uuid, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetUuid(uuid, dev)
+    return cydriver._cuDeviceGetUuid(uuid, dev)
 {{endif}}
 
 {{if 'cuDeviceGetUuid_v2' in found_functions}}
 
 cdef CUresult cuDeviceGetUuid_v2(CUuuid* uuid, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetUuid_v2(uuid, dev)
+    return cydriver._cuDeviceGetUuid_v2(uuid, dev)
 {{endif}}
 
 {{if 'cuDeviceGetLuid' in found_functions}}
 
 cdef CUresult cuDeviceGetLuid(char* luid, unsigned int* deviceNodeMask, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetLuid(luid, deviceNodeMask, dev)
+    return cydriver._cuDeviceGetLuid(luid, deviceNodeMask, dev)
 {{endif}}
 
 {{if 'cuDeviceTotalMem_v2' in found_functions}}
 
 cdef CUresult cuDeviceTotalMem(size_t* numbytes, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceTotalMem_v2(numbytes, dev)
+    return cydriver._cuDeviceTotalMem_v2(numbytes, dev)
 {{endif}}
 
 {{if 'cuDeviceGetTexture1DLinearMaxWidth' in found_functions}}
 
 cdef CUresult cuDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements, CUarray_format pformat, unsigned numChannels, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, pformat, numChannels, dev)
+    return cydriver._cuDeviceGetTexture1DLinearMaxWidth(maxWidthInElements, pformat, numChannels, dev)
 {{endif}}
 
 {{if 'cuDeviceGetAttribute' in found_functions}}
 
 cdef CUresult cuDeviceGetAttribute(int* pi, CUdevice_attribute attrib, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetAttribute(pi, attrib, dev)
+    return cydriver._cuDeviceGetAttribute(pi, attrib, dev)
 {{endif}}
 
 {{if 'cuDeviceGetNvSciSyncAttributes' in found_functions}}
 
 cdef CUresult cuDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, CUdevice dev, int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, dev, flags)
+    return cydriver._cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, dev, flags)
 {{endif}}
 
 {{if 'cuDeviceSetMemPool' in found_functions}}
 
 cdef CUresult cuDeviceSetMemPool(CUdevice dev, CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceSetMemPool(dev, pool)
+    return cydriver._cuDeviceSetMemPool(dev, pool)
 {{endif}}
 
 {{if 'cuDeviceGetMemPool' in found_functions}}
 
 cdef CUresult cuDeviceGetMemPool(CUmemoryPool* pool, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetMemPool(pool, dev)
+    return cydriver._cuDeviceGetMemPool(pool, dev)
 {{endif}}
 
 {{if 'cuDeviceGetDefaultMemPool' in found_functions}}
 
 cdef CUresult cuDeviceGetDefaultMemPool(CUmemoryPool* pool_out, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetDefaultMemPool(pool_out, dev)
+    return cydriver._cuDeviceGetDefaultMemPool(pool_out, dev)
 {{endif}}
 
 {{if 'cuFlushGPUDirectRDMAWrites' in found_functions}}
 
 cdef CUresult cuFlushGPUDirectRDMAWrites(CUflushGPUDirectRDMAWritesTarget target, CUflushGPUDirectRDMAWritesScope scope) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFlushGPUDirectRDMAWrites(target, scope)
+    return cydriver._cuFlushGPUDirectRDMAWrites(target, scope)
 {{endif}}
 
 {{if 'cuDeviceGetProperties' in found_functions}}
 
 cdef CUresult cuDeviceGetProperties(CUdevprop* prop, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetProperties(prop, dev)
+    return cydriver._cuDeviceGetProperties(prop, dev)
 {{endif}}
 
 {{if 'cuDeviceComputeCapability' in found_functions}}
 
 cdef CUresult cuDeviceComputeCapability(int* major, int* minor, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceComputeCapability(major, minor, dev)
+    return cydriver._cuDeviceComputeCapability(major, minor, dev)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxRetain' in found_functions}}
 
 cdef CUresult cuDevicePrimaryCtxRetain(CUcontext* pctx, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDevicePrimaryCtxRetain(pctx, dev)
+    return cydriver._cuDevicePrimaryCtxRetain(pctx, dev)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxRelease_v2' in found_functions}}
 
 cdef CUresult cuDevicePrimaryCtxRelease(CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDevicePrimaryCtxRelease_v2(dev)
+    return cydriver._cuDevicePrimaryCtxRelease_v2(dev)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxSetFlags_v2' in found_functions}}
 
 cdef CUresult cuDevicePrimaryCtxSetFlags(CUdevice dev, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDevicePrimaryCtxSetFlags_v2(dev, flags)
+    return cydriver._cuDevicePrimaryCtxSetFlags_v2(dev, flags)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxGetState' in found_functions}}
 
 cdef CUresult cuDevicePrimaryCtxGetState(CUdevice dev, unsigned int* flags, int* active) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDevicePrimaryCtxGetState(dev, flags, active)
+    return cydriver._cuDevicePrimaryCtxGetState(dev, flags, active)
 {{endif}}
 
 {{if 'cuDevicePrimaryCtxReset_v2' in found_functions}}
 
 cdef CUresult cuDevicePrimaryCtxReset(CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDevicePrimaryCtxReset_v2(dev)
+    return cydriver._cuDevicePrimaryCtxReset_v2(dev)
 {{endif}}
 
 {{if 'cuDeviceGetExecAffinitySupport' in found_functions}}
 
 cdef CUresult cuDeviceGetExecAffinitySupport(int* pi, CUexecAffinityType typename, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetExecAffinitySupport(pi, typename, dev)
+    return cydriver._cuDeviceGetExecAffinitySupport(pi, typename, dev)
 {{endif}}
 
 {{if 'cuCtxCreate_v2' in found_functions}}
 
 cdef CUresult cuCtxCreate(CUcontext* pctx, unsigned int flags, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxCreate_v2(pctx, flags, dev)
+    return cydriver._cuCtxCreate_v2(pctx, flags, dev)
 {{endif}}
 
 {{if 'cuCtxCreate_v3' in found_functions}}
 
 cdef CUresult cuCtxCreate_v3(CUcontext* pctx, CUexecAffinityParam* paramsArray, int numParams, unsigned int flags, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxCreate_v3(pctx, paramsArray, numParams, flags, dev)
+    return cydriver._cuCtxCreate_v3(pctx, paramsArray, numParams, flags, dev)
 {{endif}}
 
 {{if 'cuCtxDestroy_v2' in found_functions}}
 
 cdef CUresult cuCtxDestroy(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxDestroy_v2(ctx)
+    return cydriver._cuCtxDestroy_v2(ctx)
 {{endif}}
 
 {{if 'cuCtxPushCurrent_v2' in found_functions}}
 
 cdef CUresult cuCtxPushCurrent(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxPushCurrent_v2(ctx)
+    return cydriver._cuCtxPushCurrent_v2(ctx)
 {{endif}}
 
 {{if 'cuCtxPopCurrent_v2' in found_functions}}
 
 cdef CUresult cuCtxPopCurrent(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxPopCurrent_v2(pctx)
+    return cydriver._cuCtxPopCurrent_v2(pctx)
 {{endif}}
 
 {{if 'cuCtxSetCurrent' in found_functions}}
 
 cdef CUresult cuCtxSetCurrent(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxSetCurrent(ctx)
+    return cydriver._cuCtxSetCurrent(ctx)
 {{endif}}
 
 {{if 'cuCtxGetCurrent' in found_functions}}
 
 cdef CUresult cuCtxGetCurrent(CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetCurrent(pctx)
+    return cydriver._cuCtxGetCurrent(pctx)
 {{endif}}
 
 {{if 'cuCtxGetDevice' in found_functions}}
 
 cdef CUresult cuCtxGetDevice(CUdevice* device) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetDevice(device)
+    return cydriver._cuCtxGetDevice(device)
 {{endif}}
 
 {{if 'cuCtxGetFlags' in found_functions}}
 
 cdef CUresult cuCtxGetFlags(unsigned int* flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetFlags(flags)
+    return cydriver._cuCtxGetFlags(flags)
 {{endif}}
 
 {{if 'cuCtxSynchronize' in found_functions}}
 
 cdef CUresult cuCtxSynchronize() except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxSynchronize()
+    return cydriver._cuCtxSynchronize()
 {{endif}}
 
 {{if 'cuCtxSetLimit' in found_functions}}
 
 cdef CUresult cuCtxSetLimit(CUlimit limit, size_t value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxSetLimit(limit, value)
+    return cydriver._cuCtxSetLimit(limit, value)
 {{endif}}
 
 {{if 'cuCtxGetLimit' in found_functions}}
 
 cdef CUresult cuCtxGetLimit(size_t* pvalue, CUlimit limit) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetLimit(pvalue, limit)
+    return cydriver._cuCtxGetLimit(pvalue, limit)
 {{endif}}
 
 {{if 'cuCtxGetCacheConfig' in found_functions}}
 
 cdef CUresult cuCtxGetCacheConfig(CUfunc_cache* pconfig) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetCacheConfig(pconfig)
+    return cydriver._cuCtxGetCacheConfig(pconfig)
 {{endif}}
 
 {{if 'cuCtxSetCacheConfig' in found_functions}}
 
 cdef CUresult cuCtxSetCacheConfig(CUfunc_cache config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxSetCacheConfig(config)
+    return cydriver._cuCtxSetCacheConfig(config)
 {{endif}}
 
 {{if 'cuCtxGetSharedMemConfig' in found_functions}}
 
 cdef CUresult cuCtxGetSharedMemConfig(CUsharedconfig* pConfig) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetSharedMemConfig(pConfig)
+    return cydriver._cuCtxGetSharedMemConfig(pConfig)
 {{endif}}
 
 {{if 'cuCtxSetSharedMemConfig' in found_functions}}
 
 cdef CUresult cuCtxSetSharedMemConfig(CUsharedconfig config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxSetSharedMemConfig(config)
+    return cydriver._cuCtxSetSharedMemConfig(config)
 {{endif}}
 
 {{if 'cuCtxGetApiVersion' in found_functions}}
 
 cdef CUresult cuCtxGetApiVersion(CUcontext ctx, unsigned int* version) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetApiVersion(ctx, version)
+    return cydriver._cuCtxGetApiVersion(ctx, version)
 {{endif}}
 
 {{if 'cuCtxGetStreamPriorityRange' in found_functions}}
 
 cdef CUresult cuCtxGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetStreamPriorityRange(leastPriority, greatestPriority)
+    return cydriver._cuCtxGetStreamPriorityRange(leastPriority, greatestPriority)
 {{endif}}
 
 {{if 'cuCtxResetPersistingL2Cache' in found_functions}}
 
 cdef CUresult cuCtxResetPersistingL2Cache() except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxResetPersistingL2Cache()
+    return cydriver._cuCtxResetPersistingL2Cache()
 {{endif}}
 
 {{if 'cuCtxGetExecAffinity' in found_functions}}
 
 cdef CUresult cuCtxGetExecAffinity(CUexecAffinityParam* pExecAffinity, CUexecAffinityType typename) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxGetExecAffinity(pExecAffinity, typename)
+    return cydriver._cuCtxGetExecAffinity(pExecAffinity, typename)
 {{endif}}
 
 {{if 'cuCtxAttach' in found_functions}}
 
 cdef CUresult cuCtxAttach(CUcontext* pctx, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxAttach(pctx, flags)
+    return cydriver._cuCtxAttach(pctx, flags)
 {{endif}}
 
 {{if 'cuCtxDetach' in found_functions}}
 
 cdef CUresult cuCtxDetach(CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxDetach(ctx)
+    return cydriver._cuCtxDetach(ctx)
 {{endif}}
 
 {{if 'cuModuleLoad' in found_functions}}
 
 cdef CUresult cuModuleLoad(CUmodule* module, const char* fname) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleLoad(module, fname)
+    return cydriver._cuModuleLoad(module, fname)
 {{endif}}
 
 {{if 'cuModuleLoadData' in found_functions}}
 
 cdef CUresult cuModuleLoadData(CUmodule* module, const void* image) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleLoadData(module, image)
+    return cydriver._cuModuleLoadData(module, image)
 {{endif}}
 
 {{if 'cuModuleLoadDataEx' in found_functions}}
 
 cdef CUresult cuModuleLoadDataEx(CUmodule* module, const void* image, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleLoadDataEx(module, image, numOptions, options, optionValues)
+    return cydriver._cuModuleLoadDataEx(module, image, numOptions, options, optionValues)
 {{endif}}
 
 {{if 'cuModuleLoadFatBinary' in found_functions}}
 
 cdef CUresult cuModuleLoadFatBinary(CUmodule* module, const void* fatCubin) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleLoadFatBinary(module, fatCubin)
+    return cydriver._cuModuleLoadFatBinary(module, fatCubin)
 {{endif}}
 
 {{if 'cuModuleUnload' in found_functions}}
 
 cdef CUresult cuModuleUnload(CUmodule hmod) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleUnload(hmod)
+    return cydriver._cuModuleUnload(hmod)
 {{endif}}
 
 {{if 'cuModuleGetLoadingMode' in found_functions}}
 
 cdef CUresult cuModuleGetLoadingMode(CUmoduleLoadingMode* mode) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleGetLoadingMode(mode)
+    return cydriver._cuModuleGetLoadingMode(mode)
 {{endif}}
 
 {{if 'cuModuleGetFunction' in found_functions}}
 
 cdef CUresult cuModuleGetFunction(CUfunction* hfunc, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleGetFunction(hfunc, hmod, name)
+    return cydriver._cuModuleGetFunction(hfunc, hmod, name)
 {{endif}}
 
 {{if 'cuModuleGetGlobal_v2' in found_functions}}
 
 cdef CUresult cuModuleGetGlobal(CUdeviceptr* dptr, size_t* numbytes, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleGetGlobal_v2(dptr, numbytes, hmod, name)
+    return cydriver._cuModuleGetGlobal_v2(dptr, numbytes, hmod, name)
 {{endif}}
 
 {{if 'cuModuleGetTexRef' in found_functions}}
 
 cdef CUresult cuModuleGetTexRef(CUtexref* pTexRef, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleGetTexRef(pTexRef, hmod, name)
+    return cydriver._cuModuleGetTexRef(pTexRef, hmod, name)
 {{endif}}
 
 {{if 'cuModuleGetSurfRef' in found_functions}}
 
 cdef CUresult cuModuleGetSurfRef(CUsurfref* pSurfRef, CUmodule hmod, const char* name) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuModuleGetSurfRef(pSurfRef, hmod, name)
+    return cydriver._cuModuleGetSurfRef(pSurfRef, hmod, name)
 {{endif}}
 
 {{if 'cuLinkCreate_v2' in found_functions}}
 
 cdef CUresult cuLinkCreate(unsigned int numOptions, CUjit_option* options, void** optionValues, CUlinkState* stateOut) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLinkCreate_v2(numOptions, options, optionValues, stateOut)
+    return cydriver._cuLinkCreate_v2(numOptions, options, optionValues, stateOut)
 {{endif}}
 
 {{if 'cuLinkAddData_v2' in found_functions}}
 
 cdef CUresult cuLinkAddData(CUlinkState state, CUjitInputType typename, void* data, size_t size, const char* name, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLinkAddData_v2(state, typename, data, size, name, numOptions, options, optionValues)
+    return cydriver._cuLinkAddData_v2(state, typename, data, size, name, numOptions, options, optionValues)
 {{endif}}
 
 {{if 'cuLinkAddFile_v2' in found_functions}}
 
 cdef CUresult cuLinkAddFile(CUlinkState state, CUjitInputType typename, const char* path, unsigned int numOptions, CUjit_option* options, void** optionValues) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLinkAddFile_v2(state, typename, path, numOptions, options, optionValues)
+    return cydriver._cuLinkAddFile_v2(state, typename, path, numOptions, options, optionValues)
 {{endif}}
 
 {{if 'cuLinkComplete' in found_functions}}
 
 cdef CUresult cuLinkComplete(CUlinkState state, void** cubinOut, size_t* sizeOut) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLinkComplete(state, cubinOut, sizeOut)
+    return cydriver._cuLinkComplete(state, cubinOut, sizeOut)
 {{endif}}
 
 {{if 'cuLinkDestroy' in found_functions}}
 
 cdef CUresult cuLinkDestroy(CUlinkState state) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLinkDestroy(state)
+    return cydriver._cuLinkDestroy(state)
 {{endif}}
 
 {{if 'cuMemGetInfo_v2' in found_functions}}
 
 cdef CUresult cuMemGetInfo(size_t* free, size_t* total) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetInfo_v2(free, total)
+    return cydriver._cuMemGetInfo_v2(free, total)
 {{endif}}
 
 {{if 'cuMemAlloc_v2' in found_functions}}
 
 cdef CUresult cuMemAlloc(CUdeviceptr* dptr, size_t bytesize) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAlloc_v2(dptr, bytesize)
+    return cydriver._cuMemAlloc_v2(dptr, bytesize)
 {{endif}}
 
 {{if 'cuMemAllocPitch_v2' in found_functions}}
 
 cdef CUresult cuMemAllocPitch(CUdeviceptr* dptr, size_t* pPitch, size_t WidthInBytes, size_t Height, unsigned int ElementSizeBytes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAllocPitch_v2(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes)
+    return cydriver._cuMemAllocPitch_v2(dptr, pPitch, WidthInBytes, Height, ElementSizeBytes)
 {{endif}}
 
 {{if 'cuMemFree_v2' in found_functions}}
 
 cdef CUresult cuMemFree(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemFree_v2(dptr)
+    return cydriver._cuMemFree_v2(dptr)
 {{endif}}
 
 {{if 'cuMemGetAddressRange_v2' in found_functions}}
 
 cdef CUresult cuMemGetAddressRange(CUdeviceptr* pbase, size_t* psize, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetAddressRange_v2(pbase, psize, dptr)
+    return cydriver._cuMemGetAddressRange_v2(pbase, psize, dptr)
 {{endif}}
 
 {{if 'cuMemAllocHost_v2' in found_functions}}
 
 cdef CUresult cuMemAllocHost(void** pp, size_t bytesize) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAllocHost_v2(pp, bytesize)
+    return cydriver._cuMemAllocHost_v2(pp, bytesize)
 {{endif}}
 
 {{if 'cuMemFreeHost' in found_functions}}
 
 cdef CUresult cuMemFreeHost(void* p) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemFreeHost(p)
+    return cydriver._cuMemFreeHost(p)
 {{endif}}
 
 {{if 'cuMemHostAlloc' in found_functions}}
 
 cdef CUresult cuMemHostAlloc(void** pp, size_t bytesize, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemHostAlloc(pp, bytesize, Flags)
+    return cydriver._cuMemHostAlloc(pp, bytesize, Flags)
 {{endif}}
 
 {{if 'cuMemHostGetDevicePointer_v2' in found_functions}}
 
 cdef CUresult cuMemHostGetDevicePointer(CUdeviceptr* pdptr, void* p, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemHostGetDevicePointer_v2(pdptr, p, Flags)
+    return cydriver._cuMemHostGetDevicePointer_v2(pdptr, p, Flags)
 {{endif}}
 
 {{if 'cuMemHostGetFlags' in found_functions}}
 
 cdef CUresult cuMemHostGetFlags(unsigned int* pFlags, void* p) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemHostGetFlags(pFlags, p)
+    return cydriver._cuMemHostGetFlags(pFlags, p)
 {{endif}}
 
 {{if 'cuMemAllocManaged' in found_functions}}
 
 cdef CUresult cuMemAllocManaged(CUdeviceptr* dptr, size_t bytesize, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAllocManaged(dptr, bytesize, flags)
+    return cydriver._cuMemAllocManaged(dptr, bytesize, flags)
 {{endif}}
 
 {{if 'cuDeviceGetByPCIBusId' in found_functions}}
 
 cdef CUresult cuDeviceGetByPCIBusId(CUdevice* dev, const char* pciBusId) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetByPCIBusId(dev, pciBusId)
+    return cydriver._cuDeviceGetByPCIBusId(dev, pciBusId)
 {{endif}}
 
 {{if 'cuDeviceGetPCIBusId' in found_functions}}
 
 cdef CUresult cuDeviceGetPCIBusId(char* pciBusId, int length, CUdevice dev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetPCIBusId(pciBusId, length, dev)
+    return cydriver._cuDeviceGetPCIBusId(pciBusId, length, dev)
 {{endif}}
 
 {{if 'cuIpcGetEventHandle' in found_functions}}
 
 cdef CUresult cuIpcGetEventHandle(CUipcEventHandle* pHandle, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuIpcGetEventHandle(pHandle, event)
+    return cydriver._cuIpcGetEventHandle(pHandle, event)
 {{endif}}
 
 {{if 'cuIpcOpenEventHandle' in found_functions}}
 
 cdef CUresult cuIpcOpenEventHandle(CUevent* phEvent, CUipcEventHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuIpcOpenEventHandle(phEvent, handle)
+    return cydriver._cuIpcOpenEventHandle(phEvent, handle)
 {{endif}}
 
 {{if 'cuIpcGetMemHandle' in found_functions}}
 
 cdef CUresult cuIpcGetMemHandle(CUipcMemHandle* pHandle, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuIpcGetMemHandle(pHandle, dptr)
+    return cydriver._cuIpcGetMemHandle(pHandle, dptr)
 {{endif}}
 
 {{if 'cuIpcOpenMemHandle_v2' in found_functions}}
 
 cdef CUresult cuIpcOpenMemHandle(CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuIpcOpenMemHandle_v2(pdptr, handle, Flags)
+    return cydriver._cuIpcOpenMemHandle_v2(pdptr, handle, Flags)
 {{endif}}
 
 {{if 'cuIpcCloseMemHandle' in found_functions}}
 
 cdef CUresult cuIpcCloseMemHandle(CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuIpcCloseMemHandle(dptr)
+    return cydriver._cuIpcCloseMemHandle(dptr)
 {{endif}}
 
 {{if 'cuMemHostRegister_v2' in found_functions}}
 
 cdef CUresult cuMemHostRegister(void* p, size_t bytesize, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemHostRegister_v2(p, bytesize, Flags)
+    return cydriver._cuMemHostRegister_v2(p, bytesize, Flags)
 {{endif}}
 
 {{if 'cuMemHostUnregister' in found_functions}}
 
 cdef CUresult cuMemHostUnregister(void* p) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemHostUnregister(p)
+    return cydriver._cuMemHostUnregister(p)
 {{endif}}
 
 {{if 'cuMemcpy' in found_functions}}
 
 cdef CUresult cuMemcpy(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy(dst, src, ByteCount)
+    return cydriver._cuMemcpy(dst, src, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyPeer' in found_functions}}
 
 cdef CUresult cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyPeer(dstDevice, dstContext, srcDevice, srcContext, ByteCount)
+    return cydriver._cuMemcpyPeer(dstDevice, dstContext, srcDevice, srcContext, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyHtoD_v2' in found_functions}}
 
 cdef CUresult cuMemcpyHtoD(CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyHtoD_v2(dstDevice, srcHost, ByteCount)
+    return cydriver._cuMemcpyHtoD_v2(dstDevice, srcHost, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyDtoH_v2' in found_functions}}
 
 cdef CUresult cuMemcpyDtoH(void* dstHost, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyDtoH_v2(dstHost, srcDevice, ByteCount)
+    return cydriver._cuMemcpyDtoH_v2(dstHost, srcDevice, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyDtoD_v2' in found_functions}}
 
 cdef CUresult cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyDtoD_v2(dstDevice, srcDevice, ByteCount)
+    return cydriver._cuMemcpyDtoD_v2(dstDevice, srcDevice, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyDtoA_v2' in found_functions}}
 
 cdef CUresult cuMemcpyDtoA(CUarray dstArray, size_t dstOffset, CUdeviceptr srcDevice, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyDtoA_v2(dstArray, dstOffset, srcDevice, ByteCount)
+    return cydriver._cuMemcpyDtoA_v2(dstArray, dstOffset, srcDevice, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyAtoD_v2' in found_functions}}
 
 cdef CUresult cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyAtoD_v2(dstDevice, srcArray, srcOffset, ByteCount)
+    return cydriver._cuMemcpyAtoD_v2(dstDevice, srcArray, srcOffset, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyHtoA_v2' in found_functions}}
 
 cdef CUresult cuMemcpyHtoA(CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyHtoA_v2(dstArray, dstOffset, srcHost, ByteCount)
+    return cydriver._cuMemcpyHtoA_v2(dstArray, dstOffset, srcHost, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyAtoH_v2' in found_functions}}
 
 cdef CUresult cuMemcpyAtoH(void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyAtoH_v2(dstHost, srcArray, srcOffset, ByteCount)
+    return cydriver._cuMemcpyAtoH_v2(dstHost, srcArray, srcOffset, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpyAtoA_v2' in found_functions}}
 
 cdef CUresult cuMemcpyAtoA(CUarray dstArray, size_t dstOffset, CUarray srcArray, size_t srcOffset, size_t ByteCount) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyAtoA_v2(dstArray, dstOffset, srcArray, srcOffset, ByteCount)
+    return cydriver._cuMemcpyAtoA_v2(dstArray, dstOffset, srcArray, srcOffset, ByteCount)
 {{endif}}
 
 {{if 'cuMemcpy2D_v2' in found_functions}}
 
 cdef CUresult cuMemcpy2D(const CUDA_MEMCPY2D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy2D_v2(pCopy)
+    return cydriver._cuMemcpy2D_v2(pCopy)
 {{endif}}
 
 {{if 'cuMemcpy2DUnaligned_v2' in found_functions}}
 
 cdef CUresult cuMemcpy2DUnaligned(const CUDA_MEMCPY2D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy2DUnaligned_v2(pCopy)
+    return cydriver._cuMemcpy2DUnaligned_v2(pCopy)
 {{endif}}
 
 {{if 'cuMemcpy3D_v2' in found_functions}}
 
 cdef CUresult cuMemcpy3D(const CUDA_MEMCPY3D* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy3D_v2(pCopy)
+    return cydriver._cuMemcpy3D_v2(pCopy)
 {{endif}}
 
 {{if 'cuMemcpy3DPeer' in found_functions}}
 
 cdef CUresult cuMemcpy3DPeer(const CUDA_MEMCPY3D_PEER* pCopy) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy3DPeer(pCopy)
+    return cydriver._cuMemcpy3DPeer(pCopy)
 {{endif}}
 
 {{if 'cuMemcpyAsync' in found_functions}}
 
 cdef CUresult cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyAsync(dst, src, ByteCount, hStream)
+    return cydriver._cuMemcpyAsync(dst, src, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyPeerAsync' in found_functions}}
 
 cdef CUresult cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyPeerAsync(dstDevice, dstContext, srcDevice, srcContext, ByteCount, hStream)
+    return cydriver._cuMemcpyPeerAsync(dstDevice, dstContext, srcDevice, srcContext, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyHtoDAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpyHtoDAsync(CUdeviceptr dstDevice, const void* srcHost, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyHtoDAsync_v2(dstDevice, srcHost, ByteCount, hStream)
+    return cydriver._cuMemcpyHtoDAsync_v2(dstDevice, srcHost, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyDtoHAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpyDtoHAsync(void* dstHost, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyDtoHAsync_v2(dstHost, srcDevice, ByteCount, hStream)
+    return cydriver._cuMemcpyDtoHAsync_v2(dstHost, srcDevice, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyDtoDAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyDtoDAsync_v2(dstDevice, srcDevice, ByteCount, hStream)
+    return cydriver._cuMemcpyDtoDAsync_v2(dstDevice, srcDevice, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyHtoAAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpyHtoAAsync(CUarray dstArray, size_t dstOffset, const void* srcHost, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyHtoAAsync_v2(dstArray, dstOffset, srcHost, ByteCount, hStream)
+    return cydriver._cuMemcpyHtoAAsync_v2(dstArray, dstOffset, srcHost, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpyAtoHAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpyAtoHAsync(void* dstHost, CUarray srcArray, size_t srcOffset, size_t ByteCount, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpyAtoHAsync_v2(dstHost, srcArray, srcOffset, ByteCount, hStream)
+    return cydriver._cuMemcpyAtoHAsync_v2(dstHost, srcArray, srcOffset, ByteCount, hStream)
 {{endif}}
 
 {{if 'cuMemcpy2DAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpy2DAsync(const CUDA_MEMCPY2D* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy2DAsync_v2(pCopy, hStream)
+    return cydriver._cuMemcpy2DAsync_v2(pCopy, hStream)
 {{endif}}
 
 {{if 'cuMemcpy3DAsync_v2' in found_functions}}
 
 cdef CUresult cuMemcpy3DAsync(const CUDA_MEMCPY3D* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy3DAsync_v2(pCopy, hStream)
+    return cydriver._cuMemcpy3DAsync_v2(pCopy, hStream)
 {{endif}}
 
 {{if 'cuMemcpy3DPeerAsync' in found_functions}}
 
 cdef CUresult cuMemcpy3DPeerAsync(const CUDA_MEMCPY3D_PEER* pCopy, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemcpy3DPeerAsync(pCopy, hStream)
+    return cydriver._cuMemcpy3DPeerAsync(pCopy, hStream)
 {{endif}}
 
 {{if 'cuMemsetD8_v2' in found_functions}}
 
 cdef CUresult cuMemsetD8(CUdeviceptr dstDevice, unsigned char uc, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD8_v2(dstDevice, uc, N)
+    return cydriver._cuMemsetD8_v2(dstDevice, uc, N)
 {{endif}}
 
 {{if 'cuMemsetD16_v2' in found_functions}}
 
 cdef CUresult cuMemsetD16(CUdeviceptr dstDevice, unsigned short us, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD16_v2(dstDevice, us, N)
+    return cydriver._cuMemsetD16_v2(dstDevice, us, N)
 {{endif}}
 
 {{if 'cuMemsetD32_v2' in found_functions}}
 
 cdef CUresult cuMemsetD32(CUdeviceptr dstDevice, unsigned int ui, size_t N) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD32_v2(dstDevice, ui, N)
+    return cydriver._cuMemsetD32_v2(dstDevice, ui, N)
 {{endif}}
 
 {{if 'cuMemsetD2D8_v2' in found_functions}}
 
 cdef CUresult cuMemsetD2D8(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D8_v2(dstDevice, dstPitch, uc, Width, Height)
+    return cydriver._cuMemsetD2D8_v2(dstDevice, dstPitch, uc, Width, Height)
 {{endif}}
 
 {{if 'cuMemsetD2D16_v2' in found_functions}}
 
 cdef CUresult cuMemsetD2D16(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D16_v2(dstDevice, dstPitch, us, Width, Height)
+    return cydriver._cuMemsetD2D16_v2(dstDevice, dstPitch, us, Width, Height)
 {{endif}}
 
 {{if 'cuMemsetD2D32_v2' in found_functions}}
 
 cdef CUresult cuMemsetD2D32(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D32_v2(dstDevice, dstPitch, ui, Width, Height)
+    return cydriver._cuMemsetD2D32_v2(dstDevice, dstPitch, ui, Width, Height)
 {{endif}}
 
 {{if 'cuMemsetD8Async' in found_functions}}
 
 cdef CUresult cuMemsetD8Async(CUdeviceptr dstDevice, unsigned char uc, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD8Async(dstDevice, uc, N, hStream)
+    return cydriver._cuMemsetD8Async(dstDevice, uc, N, hStream)
 {{endif}}
 
 {{if 'cuMemsetD16Async' in found_functions}}
 
 cdef CUresult cuMemsetD16Async(CUdeviceptr dstDevice, unsigned short us, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD16Async(dstDevice, us, N, hStream)
+    return cydriver._cuMemsetD16Async(dstDevice, us, N, hStream)
 {{endif}}
 
 {{if 'cuMemsetD32Async' in found_functions}}
 
 cdef CUresult cuMemsetD32Async(CUdeviceptr dstDevice, unsigned int ui, size_t N, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD32Async(dstDevice, ui, N, hStream)
+    return cydriver._cuMemsetD32Async(dstDevice, ui, N, hStream)
 {{endif}}
 
 {{if 'cuMemsetD2D8Async' in found_functions}}
 
 cdef CUresult cuMemsetD2D8Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned char uc, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D8Async(dstDevice, dstPitch, uc, Width, Height, hStream)
+    return cydriver._cuMemsetD2D8Async(dstDevice, dstPitch, uc, Width, Height, hStream)
 {{endif}}
 
 {{if 'cuMemsetD2D16Async' in found_functions}}
 
 cdef CUresult cuMemsetD2D16Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned short us, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D16Async(dstDevice, dstPitch, us, Width, Height, hStream)
+    return cydriver._cuMemsetD2D16Async(dstDevice, dstPitch, us, Width, Height, hStream)
 {{endif}}
 
 {{if 'cuMemsetD2D32Async' in found_functions}}
 
 cdef CUresult cuMemsetD2D32Async(CUdeviceptr dstDevice, size_t dstPitch, unsigned int ui, size_t Width, size_t Height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemsetD2D32Async(dstDevice, dstPitch, ui, Width, Height, hStream)
+    return cydriver._cuMemsetD2D32Async(dstDevice, dstPitch, ui, Width, Height, hStream)
 {{endif}}
 
 {{if 'cuArrayCreate_v2' in found_functions}}
 
 cdef CUresult cuArrayCreate(CUarray* pHandle, const CUDA_ARRAY_DESCRIPTOR* pAllocateArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayCreate_v2(pHandle, pAllocateArray)
+    return cydriver._cuArrayCreate_v2(pHandle, pAllocateArray)
 {{endif}}
 
 {{if 'cuArrayGetDescriptor_v2' in found_functions}}
 
 cdef CUresult cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayGetDescriptor_v2(pArrayDescriptor, hArray)
+    return cydriver._cuArrayGetDescriptor_v2(pArrayDescriptor, hArray)
 {{endif}}
 
 {{if 'cuArrayGetSparseProperties' in found_functions}}
 
 cdef CUresult cuArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUarray array) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayGetSparseProperties(sparseProperties, array)
+    return cydriver._cuArrayGetSparseProperties(sparseProperties, array)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetSparseProperties' in found_functions}}
 
 cdef CUresult cuMipmappedArrayGetSparseProperties(CUDA_ARRAY_SPARSE_PROPERTIES* sparseProperties, CUmipmappedArray mipmap) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMipmappedArrayGetSparseProperties(sparseProperties, mipmap)
+    return cydriver._cuMipmappedArrayGetSparseProperties(sparseProperties, mipmap)
 {{endif}}
 
 {{if 'cuArrayGetMemoryRequirements' in found_functions}}
 
 cdef CUresult cuArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUarray array, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayGetMemoryRequirements(memoryRequirements, array, device)
+    return cydriver._cuArrayGetMemoryRequirements(memoryRequirements, array, device)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetMemoryRequirements' in found_functions}}
 
 cdef CUresult cuMipmappedArrayGetMemoryRequirements(CUDA_ARRAY_MEMORY_REQUIREMENTS* memoryRequirements, CUmipmappedArray mipmap, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)
+    return cydriver._cuMipmappedArrayGetMemoryRequirements(memoryRequirements, mipmap, device)
 {{endif}}
 
 {{if 'cuArrayGetPlane' in found_functions}}
 
 cdef CUresult cuArrayGetPlane(CUarray* pPlaneArray, CUarray hArray, unsigned int planeIdx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayGetPlane(pPlaneArray, hArray, planeIdx)
+    return cydriver._cuArrayGetPlane(pPlaneArray, hArray, planeIdx)
 {{endif}}
 
 {{if 'cuArrayDestroy' in found_functions}}
 
 cdef CUresult cuArrayDestroy(CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArrayDestroy(hArray)
+    return cydriver._cuArrayDestroy(hArray)
 {{endif}}
 
 {{if 'cuArray3DCreate_v2' in found_functions}}
 
 cdef CUresult cuArray3DCreate(CUarray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArray3DCreate_v2(pHandle, pAllocateArray)
+    return cydriver._cuArray3DCreate_v2(pHandle, pAllocateArray)
 {{endif}}
 
 {{if 'cuArray3DGetDescriptor_v2' in found_functions}}
 
 cdef CUresult cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuArray3DGetDescriptor_v2(pArrayDescriptor, hArray)
+    return cydriver._cuArray3DGetDescriptor_v2(pArrayDescriptor, hArray)
 {{endif}}
 
 {{if 'cuMipmappedArrayCreate' in found_functions}}
 
 cdef CUresult cuMipmappedArrayCreate(CUmipmappedArray* pHandle, const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc, unsigned int numMipmapLevels) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMipmappedArrayCreate(pHandle, pMipmappedArrayDesc, numMipmapLevels)
+    return cydriver._cuMipmappedArrayCreate(pHandle, pMipmappedArrayDesc, numMipmapLevels)
 {{endif}}
 
 {{if 'cuMipmappedArrayGetLevel' in found_functions}}
 
 cdef CUresult cuMipmappedArrayGetLevel(CUarray* pLevelArray, CUmipmappedArray hMipmappedArray, unsigned int level) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMipmappedArrayGetLevel(pLevelArray, hMipmappedArray, level)
+    return cydriver._cuMipmappedArrayGetLevel(pLevelArray, hMipmappedArray, level)
 {{endif}}
 
 {{if 'cuMipmappedArrayDestroy' in found_functions}}
 
 cdef CUresult cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMipmappedArrayDestroy(hMipmappedArray)
+    return cydriver._cuMipmappedArrayDestroy(hMipmappedArray)
 {{endif}}
 
 {{if 'cuMemGetHandleForAddressRange' in found_functions}}
 
 cdef CUresult cuMemGetHandleForAddressRange(void* handle, CUdeviceptr dptr, size_t size, CUmemRangeHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetHandleForAddressRange(handle, dptr, size, handleType, flags)
+    return cydriver._cuMemGetHandleForAddressRange(handle, dptr, size, handleType, flags)
 {{endif}}
 
 {{if 'cuMemAddressReserve' in found_functions}}
 
 cdef CUresult cuMemAddressReserve(CUdeviceptr* ptr, size_t size, size_t alignment, CUdeviceptr addr, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAddressReserve(ptr, size, alignment, addr, flags)
+    return cydriver._cuMemAddressReserve(ptr, size, alignment, addr, flags)
 {{endif}}
 
 {{if 'cuMemAddressFree' in found_functions}}
 
 cdef CUresult cuMemAddressFree(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAddressFree(ptr, size)
+    return cydriver._cuMemAddressFree(ptr, size)
 {{endif}}
 
 {{if 'cuMemCreate' in found_functions}}
 
 cdef CUresult cuMemCreate(CUmemGenericAllocationHandle* handle, size_t size, const CUmemAllocationProp* prop, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemCreate(handle, size, prop, flags)
+    return cydriver._cuMemCreate(handle, size, prop, flags)
 {{endif}}
 
 {{if 'cuMemRelease' in found_functions}}
 
 cdef CUresult cuMemRelease(CUmemGenericAllocationHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemRelease(handle)
+    return cydriver._cuMemRelease(handle)
 {{endif}}
 
 {{if 'cuMemMap' in found_functions}}
 
 cdef CUresult cuMemMap(CUdeviceptr ptr, size_t size, size_t offset, CUmemGenericAllocationHandle handle, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemMap(ptr, size, offset, handle, flags)
+    return cydriver._cuMemMap(ptr, size, offset, handle, flags)
 {{endif}}
 
 {{if 'cuMemMapArrayAsync' in found_functions}}
 
 cdef CUresult cuMemMapArrayAsync(CUarrayMapInfo* mapInfoList, unsigned int count, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemMapArrayAsync(mapInfoList, count, hStream)
+    return cydriver._cuMemMapArrayAsync(mapInfoList, count, hStream)
 {{endif}}
 
 {{if 'cuMemUnmap' in found_functions}}
 
 cdef CUresult cuMemUnmap(CUdeviceptr ptr, size_t size) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemUnmap(ptr, size)
+    return cydriver._cuMemUnmap(ptr, size)
 {{endif}}
 
 {{if 'cuMemSetAccess' in found_functions}}
 
 cdef CUresult cuMemSetAccess(CUdeviceptr ptr, size_t size, const CUmemAccessDesc* desc, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemSetAccess(ptr, size, desc, count)
+    return cydriver._cuMemSetAccess(ptr, size, desc, count)
 {{endif}}
 
 {{if 'cuMemGetAccess' in found_functions}}
 
 cdef CUresult cuMemGetAccess(unsigned long long* flags, const CUmemLocation* location, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetAccess(flags, location, ptr)
+    return cydriver._cuMemGetAccess(flags, location, ptr)
 {{endif}}
 
 {{if 'cuMemExportToShareableHandle' in found_functions}}
 
 cdef CUresult cuMemExportToShareableHandle(void* shareableHandle, CUmemGenericAllocationHandle handle, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemExportToShareableHandle(shareableHandle, handle, handleType, flags)
+    return cydriver._cuMemExportToShareableHandle(shareableHandle, handle, handleType, flags)
 {{endif}}
 
 {{if 'cuMemImportFromShareableHandle' in found_functions}}
 
 cdef CUresult cuMemImportFromShareableHandle(CUmemGenericAllocationHandle* handle, void* osHandle, CUmemAllocationHandleType shHandleType) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemImportFromShareableHandle(handle, osHandle, shHandleType)
+    return cydriver._cuMemImportFromShareableHandle(handle, osHandle, shHandleType)
 {{endif}}
 
 {{if 'cuMemGetAllocationGranularity' in found_functions}}
 
 cdef CUresult cuMemGetAllocationGranularity(size_t* granularity, const CUmemAllocationProp* prop, CUmemAllocationGranularity_flags option) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetAllocationGranularity(granularity, prop, option)
+    return cydriver._cuMemGetAllocationGranularity(granularity, prop, option)
 {{endif}}
 
 {{if 'cuMemGetAllocationPropertiesFromHandle' in found_functions}}
 
 cdef CUresult cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp* prop, CUmemGenericAllocationHandle handle) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemGetAllocationPropertiesFromHandle(prop, handle)
+    return cydriver._cuMemGetAllocationPropertiesFromHandle(prop, handle)
 {{endif}}
 
 {{if 'cuMemRetainAllocationHandle' in found_functions}}
 
 cdef CUresult cuMemRetainAllocationHandle(CUmemGenericAllocationHandle* handle, void* addr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemRetainAllocationHandle(handle, addr)
+    return cydriver._cuMemRetainAllocationHandle(handle, addr)
 {{endif}}
 
 {{if 'cuMemFreeAsync' in found_functions}}
 
 cdef CUresult cuMemFreeAsync(CUdeviceptr dptr, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemFreeAsync(dptr, hStream)
+    return cydriver._cuMemFreeAsync(dptr, hStream)
 {{endif}}
 
 {{if 'cuMemAllocAsync' in found_functions}}
 
 cdef CUresult cuMemAllocAsync(CUdeviceptr* dptr, size_t bytesize, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAllocAsync(dptr, bytesize, hStream)
+    return cydriver._cuMemAllocAsync(dptr, bytesize, hStream)
 {{endif}}
 
 {{if 'cuMemPoolTrimTo' in found_functions}}
 
 cdef CUresult cuMemPoolTrimTo(CUmemoryPool pool, size_t minBytesToKeep) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolTrimTo(pool, minBytesToKeep)
+    return cydriver._cuMemPoolTrimTo(pool, minBytesToKeep)
 {{endif}}
 
 {{if 'cuMemPoolSetAttribute' in found_functions}}
 
 cdef CUresult cuMemPoolSetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolSetAttribute(pool, attr, value)
+    return cydriver._cuMemPoolSetAttribute(pool, attr, value)
 {{endif}}
 
 {{if 'cuMemPoolGetAttribute' in found_functions}}
 
 cdef CUresult cuMemPoolGetAttribute(CUmemoryPool pool, CUmemPool_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolGetAttribute(pool, attr, value)
+    return cydriver._cuMemPoolGetAttribute(pool, attr, value)
 {{endif}}
 
 {{if 'cuMemPoolSetAccess' in found_functions}}
 
 cdef CUresult cuMemPoolSetAccess(CUmemoryPool pool, const CUmemAccessDesc* map, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolSetAccess(pool, map, count)
+    return cydriver._cuMemPoolSetAccess(pool, map, count)
 {{endif}}
 
 {{if 'cuMemPoolGetAccess' in found_functions}}
 
 cdef CUresult cuMemPoolGetAccess(CUmemAccess_flags* flags, CUmemoryPool memPool, CUmemLocation* location) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolGetAccess(flags, memPool, location)
+    return cydriver._cuMemPoolGetAccess(flags, memPool, location)
 {{endif}}
 
 {{if 'cuMemPoolCreate' in found_functions}}
 
 cdef CUresult cuMemPoolCreate(CUmemoryPool* pool, const CUmemPoolProps* poolProps) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolCreate(pool, poolProps)
+    return cydriver._cuMemPoolCreate(pool, poolProps)
 {{endif}}
 
 {{if 'cuMemPoolDestroy' in found_functions}}
 
 cdef CUresult cuMemPoolDestroy(CUmemoryPool pool) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolDestroy(pool)
+    return cydriver._cuMemPoolDestroy(pool)
 {{endif}}
 
 {{if 'cuMemAllocFromPoolAsync' in found_functions}}
 
 cdef CUresult cuMemAllocFromPoolAsync(CUdeviceptr* dptr, size_t bytesize, CUmemoryPool pool, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAllocFromPoolAsync(dptr, bytesize, pool, hStream)
+    return cydriver._cuMemAllocFromPoolAsync(dptr, bytesize, pool, hStream)
 {{endif}}
 
 {{if 'cuMemPoolExportToShareableHandle' in found_functions}}
 
 cdef CUresult cuMemPoolExportToShareableHandle(void* handle_out, CUmemoryPool pool, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolExportToShareableHandle(handle_out, pool, handleType, flags)
+    return cydriver._cuMemPoolExportToShareableHandle(handle_out, pool, handleType, flags)
 {{endif}}
 
 {{if 'cuMemPoolImportFromShareableHandle' in found_functions}}
 
 cdef CUresult cuMemPoolImportFromShareableHandle(CUmemoryPool* pool_out, void* handle, CUmemAllocationHandleType handleType, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolImportFromShareableHandle(pool_out, handle, handleType, flags)
+    return cydriver._cuMemPoolImportFromShareableHandle(pool_out, handle, handleType, flags)
 {{endif}}
 
 {{if 'cuMemPoolExportPointer' in found_functions}}
 
 cdef CUresult cuMemPoolExportPointer(CUmemPoolPtrExportData* shareData_out, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolExportPointer(shareData_out, ptr)
+    return cydriver._cuMemPoolExportPointer(shareData_out, ptr)
 {{endif}}
 
 {{if 'cuMemPoolImportPointer' in found_functions}}
 
 cdef CUresult cuMemPoolImportPointer(CUdeviceptr* ptr_out, CUmemoryPool pool, CUmemPoolPtrExportData* shareData) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPoolImportPointer(ptr_out, pool, shareData)
+    return cydriver._cuMemPoolImportPointer(ptr_out, pool, shareData)
 {{endif}}
 
 {{if 'cuPointerGetAttribute' in found_functions}}
 
 cdef CUresult cuPointerGetAttribute(void* data, CUpointer_attribute attribute, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuPointerGetAttribute(data, attribute, ptr)
+    return cydriver._cuPointerGetAttribute(data, attribute, ptr)
 {{endif}}
 
 {{if 'cuMemPrefetchAsync' in found_functions}}
 
 cdef CUresult cuMemPrefetchAsync(CUdeviceptr devPtr, size_t count, CUdevice dstDevice, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemPrefetchAsync(devPtr, count, dstDevice, hStream)
+    return cydriver._cuMemPrefetchAsync(devPtr, count, dstDevice, hStream)
 {{endif}}
 
 {{if 'cuMemAdvise' in found_functions}}
 
 cdef CUresult cuMemAdvise(CUdeviceptr devPtr, size_t count, CUmem_advise advice, CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemAdvise(devPtr, count, advice, device)
+    return cydriver._cuMemAdvise(devPtr, count, advice, device)
 {{endif}}
 
 {{if 'cuMemRangeGetAttribute' in found_functions}}
 
 cdef CUresult cuMemRangeGetAttribute(void* data, size_t dataSize, CUmem_range_attribute attribute, CUdeviceptr devPtr, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)
+    return cydriver._cuMemRangeGetAttribute(data, dataSize, attribute, devPtr, count)
 {{endif}}
 
 {{if 'cuMemRangeGetAttributes' in found_functions}}
 
 cdef CUresult cuMemRangeGetAttributes(void** data, size_t* dataSizes, CUmem_range_attribute* attributes, size_t numAttributes, CUdeviceptr devPtr, size_t count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)
+    return cydriver._cuMemRangeGetAttributes(data, dataSizes, attributes, numAttributes, devPtr, count)
 {{endif}}
 
 {{if 'cuPointerSetAttribute' in found_functions}}
 
 cdef CUresult cuPointerSetAttribute(const void* value, CUpointer_attribute attribute, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuPointerSetAttribute(value, attribute, ptr)
+    return cydriver._cuPointerSetAttribute(value, attribute, ptr)
 {{endif}}
 
 {{if 'cuPointerGetAttributes' in found_functions}}
 
 cdef CUresult cuPointerGetAttributes(unsigned int numAttributes, CUpointer_attribute* attributes, void** data, CUdeviceptr ptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuPointerGetAttributes(numAttributes, attributes, data, ptr)
+    return cydriver._cuPointerGetAttributes(numAttributes, attributes, data, ptr)
 {{endif}}
 
 {{if 'cuStreamCreate' in found_functions}}
 
 cdef CUresult cuStreamCreate(CUstream* phStream, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamCreate(phStream, Flags)
+    return cydriver._cuStreamCreate(phStream, Flags)
 {{endif}}
 
 {{if 'cuStreamCreateWithPriority' in found_functions}}
 
 cdef CUresult cuStreamCreateWithPriority(CUstream* phStream, unsigned int flags, int priority) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamCreateWithPriority(phStream, flags, priority)
+    return cydriver._cuStreamCreateWithPriority(phStream, flags, priority)
 {{endif}}
 
 {{if 'cuStreamGetPriority' in found_functions}}
 
 cdef CUresult cuStreamGetPriority(CUstream hStream, int* priority) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetPriority(hStream, priority)
+    return cydriver._cuStreamGetPriority(hStream, priority)
 {{endif}}
 
 {{if 'cuStreamGetFlags' in found_functions}}
 
 cdef CUresult cuStreamGetFlags(CUstream hStream, unsigned int* flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetFlags(hStream, flags)
+    return cydriver._cuStreamGetFlags(hStream, flags)
 {{endif}}
 
 {{if 'cuStreamGetCtx' in found_functions}}
 
 cdef CUresult cuStreamGetCtx(CUstream hStream, CUcontext* pctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetCtx(hStream, pctx)
+    return cydriver._cuStreamGetCtx(hStream, pctx)
 {{endif}}
 
 {{if 'cuStreamWaitEvent' in found_functions}}
 
 cdef CUresult cuStreamWaitEvent(CUstream hStream, CUevent hEvent, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWaitEvent(hStream, hEvent, Flags)
+    return cydriver._cuStreamWaitEvent(hStream, hEvent, Flags)
 {{endif}}
 
 {{if 'cuStreamAddCallback' in found_functions}}
 
 cdef CUresult cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, void* userData, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamAddCallback(hStream, callback, userData, flags)
+    return cydriver._cuStreamAddCallback(hStream, callback, userData, flags)
 {{endif}}
 
 {{if 'cuStreamBeginCapture_v2' in found_functions}}
 
 cdef CUresult cuStreamBeginCapture(CUstream hStream, CUstreamCaptureMode mode) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamBeginCapture_v2(hStream, mode)
+    return cydriver._cuStreamBeginCapture_v2(hStream, mode)
 {{endif}}
 
 {{if 'cuThreadExchangeStreamCaptureMode' in found_functions}}
 
 cdef CUresult cuThreadExchangeStreamCaptureMode(CUstreamCaptureMode* mode) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuThreadExchangeStreamCaptureMode(mode)
+    return cydriver._cuThreadExchangeStreamCaptureMode(mode)
 {{endif}}
 
 {{if 'cuStreamEndCapture' in found_functions}}
 
 cdef CUresult cuStreamEndCapture(CUstream hStream, CUgraph* phGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamEndCapture(hStream, phGraph)
+    return cydriver._cuStreamEndCapture(hStream, phGraph)
 {{endif}}
 
 {{if 'cuStreamIsCapturing' in found_functions}}
 
 cdef CUresult cuStreamIsCapturing(CUstream hStream, CUstreamCaptureStatus* captureStatus) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamIsCapturing(hStream, captureStatus)
+    return cydriver._cuStreamIsCapturing(hStream, captureStatus)
 {{endif}}
 
 {{if 'cuStreamGetCaptureInfo' in found_functions}}
 
 cdef CUresult cuStreamGetCaptureInfo(CUstream hStream, CUstreamCaptureStatus* captureStatus_out, cuuint64_t* id_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetCaptureInfo(hStream, captureStatus_out, id_out)
+    return cydriver._cuStreamGetCaptureInfo(hStream, captureStatus_out, id_out)
 {{endif}}
 
 {{if 'cuStreamGetCaptureInfo_v2' in found_functions}}
 
 cdef CUresult cuStreamGetCaptureInfo_v2(CUstream hStream, CUstreamCaptureStatus* captureStatus_out, cuuint64_t* id_out, CUgraph* graph_out, const CUgraphNode** dependencies_out, size_t* numDependencies_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetCaptureInfo_v2(hStream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
+    return cydriver._cuStreamGetCaptureInfo_v2(hStream, captureStatus_out, id_out, graph_out, dependencies_out, numDependencies_out)
 {{endif}}
 
 {{if 'cuStreamUpdateCaptureDependencies' in found_functions}}
 
 cdef CUresult cuStreamUpdateCaptureDependencies(CUstream hStream, CUgraphNode* dependencies, size_t numDependencies, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamUpdateCaptureDependencies(hStream, dependencies, numDependencies, flags)
+    return cydriver._cuStreamUpdateCaptureDependencies(hStream, dependencies, numDependencies, flags)
 {{endif}}
 
 {{if 'cuStreamAttachMemAsync' in found_functions}}
 
 cdef CUresult cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, size_t length, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamAttachMemAsync(hStream, dptr, length, flags)
+    return cydriver._cuStreamAttachMemAsync(hStream, dptr, length, flags)
 {{endif}}
 
 {{if 'cuStreamQuery' in found_functions}}
 
 cdef CUresult cuStreamQuery(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamQuery(hStream)
+    return cydriver._cuStreamQuery(hStream)
 {{endif}}
 
 {{if 'cuStreamSynchronize' in found_functions}}
 
 cdef CUresult cuStreamSynchronize(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamSynchronize(hStream)
+    return cydriver._cuStreamSynchronize(hStream)
 {{endif}}
 
 {{if 'cuStreamDestroy_v2' in found_functions}}
 
 cdef CUresult cuStreamDestroy(CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamDestroy_v2(hStream)
+    return cydriver._cuStreamDestroy_v2(hStream)
 {{endif}}
 
 {{if 'cuStreamCopyAttributes' in found_functions}}
 
 cdef CUresult cuStreamCopyAttributes(CUstream dst, CUstream src) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamCopyAttributes(dst, src)
+    return cydriver._cuStreamCopyAttributes(dst, src)
 {{endif}}
 
 {{if 'cuStreamGetAttribute' in found_functions}}
 
 cdef CUresult cuStreamGetAttribute(CUstream hStream, CUstreamAttrID attr, CUstreamAttrValue* value_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamGetAttribute(hStream, attr, value_out)
+    return cydriver._cuStreamGetAttribute(hStream, attr, value_out)
 {{endif}}
 
 {{if 'cuStreamSetAttribute' in found_functions}}
 
 cdef CUresult cuStreamSetAttribute(CUstream hStream, CUstreamAttrID attr, const CUstreamAttrValue* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamSetAttribute(hStream, attr, value)
+    return cydriver._cuStreamSetAttribute(hStream, attr, value)
 {{endif}}
 
 {{if 'cuEventCreate' in found_functions}}
 
 cdef CUresult cuEventCreate(CUevent* phEvent, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventCreate(phEvent, Flags)
+    return cydriver._cuEventCreate(phEvent, Flags)
 {{endif}}
 
 {{if 'cuEventRecord' in found_functions}}
 
 cdef CUresult cuEventRecord(CUevent hEvent, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventRecord(hEvent, hStream)
+    return cydriver._cuEventRecord(hEvent, hStream)
 {{endif}}
 
 {{if 'cuEventRecordWithFlags' in found_functions}}
 
 cdef CUresult cuEventRecordWithFlags(CUevent hEvent, CUstream hStream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventRecordWithFlags(hEvent, hStream, flags)
+    return cydriver._cuEventRecordWithFlags(hEvent, hStream, flags)
 {{endif}}
 
 {{if 'cuEventQuery' in found_functions}}
 
 cdef CUresult cuEventQuery(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventQuery(hEvent)
+    return cydriver._cuEventQuery(hEvent)
 {{endif}}
 
 {{if 'cuEventSynchronize' in found_functions}}
 
 cdef CUresult cuEventSynchronize(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventSynchronize(hEvent)
+    return cydriver._cuEventSynchronize(hEvent)
 {{endif}}
 
 {{if 'cuEventDestroy_v2' in found_functions}}
 
 cdef CUresult cuEventDestroy(CUevent hEvent) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventDestroy_v2(hEvent)
+    return cydriver._cuEventDestroy_v2(hEvent)
 {{endif}}
 
 {{if 'cuEventElapsedTime' in found_functions}}
 
 cdef CUresult cuEventElapsedTime(float* pMilliseconds, CUevent hStart, CUevent hEnd) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventElapsedTime(pMilliseconds, hStart, hEnd)
+    return cydriver._cuEventElapsedTime(pMilliseconds, hStart, hEnd)
 {{endif}}
 
 {{if 'cuImportExternalMemory' in found_functions}}
 
 cdef CUresult cuImportExternalMemory(CUexternalMemory* extMem_out, const CUDA_EXTERNAL_MEMORY_HANDLE_DESC* memHandleDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuImportExternalMemory(extMem_out, memHandleDesc)
+    return cydriver._cuImportExternalMemory(extMem_out, memHandleDesc)
 {{endif}}
 
 {{if 'cuExternalMemoryGetMappedBuffer' in found_functions}}
 
 cdef CUresult cuExternalMemoryGetMappedBuffer(CUdeviceptr* devPtr, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_BUFFER_DESC* bufferDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)
+    return cydriver._cuExternalMemoryGetMappedBuffer(devPtr, extMem, bufferDesc)
 {{endif}}
 
 {{if 'cuExternalMemoryGetMappedMipmappedArray' in found_functions}}
 
 cdef CUresult cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray* mipmap, CUexternalMemory extMem, const CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* mipmapDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)
+    return cydriver._cuExternalMemoryGetMappedMipmappedArray(mipmap, extMem, mipmapDesc)
 {{endif}}
 
 {{if 'cuDestroyExternalMemory' in found_functions}}
 
 cdef CUresult cuDestroyExternalMemory(CUexternalMemory extMem) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDestroyExternalMemory(extMem)
+    return cydriver._cuDestroyExternalMemory(extMem)
 {{endif}}
 
 {{if 'cuImportExternalSemaphore' in found_functions}}
 
 cdef CUresult cuImportExternalSemaphore(CUexternalSemaphore* extSem_out, const CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* semHandleDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuImportExternalSemaphore(extSem_out, semHandleDesc)
+    return cydriver._cuImportExternalSemaphore(extSem_out, semHandleDesc)
 {{endif}}
 
 {{if 'cuSignalExternalSemaphoresAsync' in found_functions}}
 
 cdef CUresult cuSignalExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
+    return cydriver._cuSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
 {{endif}}
 
 {{if 'cuWaitExternalSemaphoresAsync' in found_functions}}
 
 cdef CUresult cuWaitExternalSemaphoresAsync(const CUexternalSemaphore* extSemArray, const CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* paramsArray, unsigned int numExtSems, CUstream stream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
+    return cydriver._cuWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
 {{endif}}
 
 {{if 'cuDestroyExternalSemaphore' in found_functions}}
 
 cdef CUresult cuDestroyExternalSemaphore(CUexternalSemaphore extSem) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDestroyExternalSemaphore(extSem)
+    return cydriver._cuDestroyExternalSemaphore(extSem)
 {{endif}}
 
 {{if 'cuStreamWaitValue32' in found_functions}}
 
 cdef CUresult cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWaitValue32(stream, addr, value, flags)
+    return cydriver._cuStreamWaitValue32(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWaitValue64' in found_functions}}
 
 cdef CUresult cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWaitValue64(stream, addr, value, flags)
+    return cydriver._cuStreamWaitValue64(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWriteValue32' in found_functions}}
 
 cdef CUresult cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWriteValue32(stream, addr, value, flags)
+    return cydriver._cuStreamWriteValue32(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWriteValue64' in found_functions}}
 
 cdef CUresult cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWriteValue64(stream, addr, value, flags)
+    return cydriver._cuStreamWriteValue64(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamBatchMemOp' in found_functions}}
 
 cdef CUresult cuStreamBatchMemOp(CUstream stream, unsigned int count, CUstreamBatchMemOpParams* paramArray, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamBatchMemOp(stream, count, paramArray, flags)
+    return cydriver._cuStreamBatchMemOp(stream, count, paramArray, flags)
 {{endif}}
 
 {{if 'cuStreamWaitValue32_v2' in found_functions}}
 
 cdef CUresult cuStreamWaitValue32_v2(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWaitValue32_v2(stream, addr, value, flags)
+    return cydriver._cuStreamWaitValue32_v2(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWaitValue64_v2' in found_functions}}
 
 cdef CUresult cuStreamWaitValue64_v2(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWaitValue64_v2(stream, addr, value, flags)
+    return cydriver._cuStreamWaitValue64_v2(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWriteValue32_v2' in found_functions}}
 
 cdef CUresult cuStreamWriteValue32_v2(CUstream stream, CUdeviceptr addr, cuuint32_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWriteValue32_v2(stream, addr, value, flags)
+    return cydriver._cuStreamWriteValue32_v2(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamWriteValue64_v2' in found_functions}}
 
 cdef CUresult cuStreamWriteValue64_v2(CUstream stream, CUdeviceptr addr, cuuint64_t value, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamWriteValue64_v2(stream, addr, value, flags)
+    return cydriver._cuStreamWriteValue64_v2(stream, addr, value, flags)
 {{endif}}
 
 {{if 'cuStreamBatchMemOp_v2' in found_functions}}
 
 cdef CUresult cuStreamBatchMemOp_v2(CUstream stream, unsigned int count, CUstreamBatchMemOpParams* paramArray, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuStreamBatchMemOp_v2(stream, count, paramArray, flags)
+    return cydriver._cuStreamBatchMemOp_v2(stream, count, paramArray, flags)
 {{endif}}
 
 {{if 'cuFuncGetAttribute' in found_functions}}
 
 cdef CUresult cuFuncGetAttribute(int* pi, CUfunction_attribute attrib, CUfunction hfunc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncGetAttribute(pi, attrib, hfunc)
+    return cydriver._cuFuncGetAttribute(pi, attrib, hfunc)
 {{endif}}
 
 {{if 'cuFuncSetAttribute' in found_functions}}
 
 cdef CUresult cuFuncSetAttribute(CUfunction hfunc, CUfunction_attribute attrib, int value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncSetAttribute(hfunc, attrib, value)
+    return cydriver._cuFuncSetAttribute(hfunc, attrib, value)
 {{endif}}
 
 {{if 'cuFuncSetCacheConfig' in found_functions}}
 
 cdef CUresult cuFuncSetCacheConfig(CUfunction hfunc, CUfunc_cache config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncSetCacheConfig(hfunc, config)
+    return cydriver._cuFuncSetCacheConfig(hfunc, config)
 {{endif}}
 
 {{if 'cuFuncSetSharedMemConfig' in found_functions}}
 
 cdef CUresult cuFuncSetSharedMemConfig(CUfunction hfunc, CUsharedconfig config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncSetSharedMemConfig(hfunc, config)
+    return cydriver._cuFuncSetSharedMemConfig(hfunc, config)
 {{endif}}
 
 {{if 'cuFuncGetModule' in found_functions}}
 
 cdef CUresult cuFuncGetModule(CUmodule* hmod, CUfunction hfunc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncGetModule(hmod, hfunc)
+    return cydriver._cuFuncGetModule(hmod, hfunc)
 {{endif}}
 
 {{if 'cuLaunchKernel' in found_functions}}
 
 cdef CUresult cuLaunchKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void** kernelParams, void** extra) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra)
+    return cydriver._cuLaunchKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams, extra)
 {{endif}}
 
 {{if 'cuLaunchKernelEx' in found_functions}}
 
 cdef CUresult cuLaunchKernelEx(const CUlaunchConfig* config, CUfunction f, void** kernelParams, void** extra) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchKernelEx(config, f, kernelParams, extra)
+    return cydriver._cuLaunchKernelEx(config, f, kernelParams, extra)
 {{endif}}
 
 {{if 'cuLaunchCooperativeKernel' in found_functions}}
 
 cdef CUresult cuLaunchCooperativeKernel(CUfunction f, unsigned int gridDimX, unsigned int gridDimY, unsigned int gridDimZ, unsigned int blockDimX, unsigned int blockDimY, unsigned int blockDimZ, unsigned int sharedMemBytes, CUstream hStream, void** kernelParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchCooperativeKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams)
+    return cydriver._cuLaunchCooperativeKernel(f, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, hStream, kernelParams)
 {{endif}}
 
 {{if 'cuLaunchCooperativeKernelMultiDevice' in found_functions}}
 
 cdef CUresult cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS* launchParamsList, unsigned int numDevices, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags)
+    return cydriver._cuLaunchCooperativeKernelMultiDevice(launchParamsList, numDevices, flags)
 {{endif}}
 
 {{if 'cuLaunchHostFunc' in found_functions}}
 
 cdef CUresult cuLaunchHostFunc(CUstream hStream, CUhostFn fn, void* userData) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchHostFunc(hStream, fn, userData)
+    return cydriver._cuLaunchHostFunc(hStream, fn, userData)
 {{endif}}
 
 {{if 'cuFuncSetBlockShape' in found_functions}}
 
 cdef CUresult cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncSetBlockShape(hfunc, x, y, z)
+    return cydriver._cuFuncSetBlockShape(hfunc, x, y, z)
 {{endif}}
 
 {{if 'cuFuncSetSharedSize' in found_functions}}
 
 cdef CUresult cuFuncSetSharedSize(CUfunction hfunc, unsigned int numbytes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuFuncSetSharedSize(hfunc, numbytes)
+    return cydriver._cuFuncSetSharedSize(hfunc, numbytes)
 {{endif}}
 
 {{if 'cuParamSetSize' in found_functions}}
 
 cdef CUresult cuParamSetSize(CUfunction hfunc, unsigned int numbytes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuParamSetSize(hfunc, numbytes)
+    return cydriver._cuParamSetSize(hfunc, numbytes)
 {{endif}}
 
 {{if 'cuParamSeti' in found_functions}}
 
 cdef CUresult cuParamSeti(CUfunction hfunc, int offset, unsigned int value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuParamSeti(hfunc, offset, value)
+    return cydriver._cuParamSeti(hfunc, offset, value)
 {{endif}}
 
 {{if 'cuParamSetf' in found_functions}}
 
 cdef CUresult cuParamSetf(CUfunction hfunc, int offset, float value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuParamSetf(hfunc, offset, value)
+    return cydriver._cuParamSetf(hfunc, offset, value)
 {{endif}}
 
 {{if 'cuParamSetv' in found_functions}}
 
 cdef CUresult cuParamSetv(CUfunction hfunc, int offset, void* ptr, unsigned int numbytes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuParamSetv(hfunc, offset, ptr, numbytes)
+    return cydriver._cuParamSetv(hfunc, offset, ptr, numbytes)
 {{endif}}
 
 {{if 'cuLaunch' in found_functions}}
 
 cdef CUresult cuLaunch(CUfunction f) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunch(f)
+    return cydriver._cuLaunch(f)
 {{endif}}
 
 {{if 'cuLaunchGrid' in found_functions}}
 
 cdef CUresult cuLaunchGrid(CUfunction f, int grid_width, int grid_height) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchGrid(f, grid_width, grid_height)
+    return cydriver._cuLaunchGrid(f, grid_width, grid_height)
 {{endif}}
 
 {{if 'cuLaunchGridAsync' in found_functions}}
 
 cdef CUresult cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuLaunchGridAsync(f, grid_width, grid_height, hStream)
+    return cydriver._cuLaunchGridAsync(f, grid_width, grid_height, hStream)
 {{endif}}
 
 {{if 'cuParamSetTexRef' in found_functions}}
 
 cdef CUresult cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuParamSetTexRef(hfunc, texunit, hTexRef)
+    return cydriver._cuParamSetTexRef(hfunc, texunit, hTexRef)
 {{endif}}
 
 {{if 'cuGraphCreate' in found_functions}}
 
 cdef CUresult cuGraphCreate(CUgraph* phGraph, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphCreate(phGraph, flags)
+    return cydriver._cuGraphCreate(phGraph, flags)
 {{endif}}
 
 {{if 'cuGraphAddKernelNode' in found_functions}}
 
 cdef CUresult cuGraphAddKernelNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddKernelNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddKernelNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphKernelNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphKernelNodeGetParams(hNode, nodeParams)
+    return cydriver._cuGraphKernelNodeGetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphKernelNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphKernelNodeSetParams(CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphKernelNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphKernelNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddMemcpyNode' in found_functions}}
 
 cdef CUresult cuGraphAddMemcpyNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_MEMCPY3D* copyParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddMemcpyNode(phGraphNode, hGraph, dependencies, numDependencies, copyParams, ctx)
+    return cydriver._cuGraphAddMemcpyNode(phGraphNode, hGraph, dependencies, numDependencies, copyParams, ctx)
 {{endif}}
 
 {{if 'cuGraphMemcpyNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphMemcpyNodeGetParams(CUgraphNode hNode, CUDA_MEMCPY3D* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemcpyNodeGetParams(hNode, nodeParams)
+    return cydriver._cuGraphMemcpyNodeGetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphMemcpyNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphMemcpyNodeSetParams(CUgraphNode hNode, const CUDA_MEMCPY3D* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemcpyNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphMemcpyNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddMemsetNode' in found_functions}}
 
 cdef CUresult cuGraphAddMemsetNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_MEMSET_NODE_PARAMS* memsetParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddMemsetNode(phGraphNode, hGraph, dependencies, numDependencies, memsetParams, ctx)
+    return cydriver._cuGraphAddMemsetNode(phGraphNode, hGraph, dependencies, numDependencies, memsetParams, ctx)
 {{endif}}
 
 {{if 'cuGraphMemsetNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphMemsetNodeGetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemsetNodeGetParams(hNode, nodeParams)
+    return cydriver._cuGraphMemsetNodeGetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphMemsetNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphMemsetNodeSetParams(CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemsetNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphMemsetNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddHostNode' in found_functions}}
 
 cdef CUresult cuGraphAddHostNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddHostNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddHostNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphHostNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphHostNodeGetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphHostNodeGetParams(hNode, nodeParams)
+    return cydriver._cuGraphHostNodeGetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphHostNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphHostNodeSetParams(CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphHostNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphHostNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddChildGraphNode' in found_functions}}
 
 cdef CUresult cuGraphAddChildGraphNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUgraph childGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddChildGraphNode(phGraphNode, hGraph, dependencies, numDependencies, childGraph)
+    return cydriver._cuGraphAddChildGraphNode(phGraphNode, hGraph, dependencies, numDependencies, childGraph)
 {{endif}}
 
 {{if 'cuGraphChildGraphNodeGetGraph' in found_functions}}
 
 cdef CUresult cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, CUgraph* phGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphChildGraphNodeGetGraph(hNode, phGraph)
+    return cydriver._cuGraphChildGraphNodeGetGraph(hNode, phGraph)
 {{endif}}
 
 {{if 'cuGraphAddEmptyNode' in found_functions}}
 
 cdef CUresult cuGraphAddEmptyNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddEmptyNode(phGraphNode, hGraph, dependencies, numDependencies)
+    return cydriver._cuGraphAddEmptyNode(phGraphNode, hGraph, dependencies, numDependencies)
 {{endif}}
 
 {{if 'cuGraphAddEventRecordNode' in found_functions}}
 
 cdef CUresult cuGraphAddEventRecordNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddEventRecordNode(phGraphNode, hGraph, dependencies, numDependencies, event)
+    return cydriver._cuGraphAddEventRecordNode(phGraphNode, hGraph, dependencies, numDependencies, event)
 {{endif}}
 
 {{if 'cuGraphEventRecordNodeGetEvent' in found_functions}}
 
 cdef CUresult cuGraphEventRecordNodeGetEvent(CUgraphNode hNode, CUevent* event_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphEventRecordNodeGetEvent(hNode, event_out)
+    return cydriver._cuGraphEventRecordNodeGetEvent(hNode, event_out)
 {{endif}}
 
 {{if 'cuGraphEventRecordNodeSetEvent' in found_functions}}
 
 cdef CUresult cuGraphEventRecordNodeSetEvent(CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphEventRecordNodeSetEvent(hNode, event)
+    return cydriver._cuGraphEventRecordNodeSetEvent(hNode, event)
 {{endif}}
 
 {{if 'cuGraphAddEventWaitNode' in found_functions}}
 
 cdef CUresult cuGraphAddEventWaitNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddEventWaitNode(phGraphNode, hGraph, dependencies, numDependencies, event)
+    return cydriver._cuGraphAddEventWaitNode(phGraphNode, hGraph, dependencies, numDependencies, event)
 {{endif}}
 
 {{if 'cuGraphEventWaitNodeGetEvent' in found_functions}}
 
 cdef CUresult cuGraphEventWaitNodeGetEvent(CUgraphNode hNode, CUevent* event_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphEventWaitNodeGetEvent(hNode, event_out)
+    return cydriver._cuGraphEventWaitNodeGetEvent(hNode, event_out)
 {{endif}}
 
 {{if 'cuGraphEventWaitNodeSetEvent' in found_functions}}
 
 cdef CUresult cuGraphEventWaitNodeSetEvent(CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphEventWaitNodeSetEvent(hNode, event)
+    return cydriver._cuGraphEventWaitNodeSetEvent(hNode, event)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresSignalNode' in found_functions}}
 
 cdef CUresult cuGraphAddExternalSemaphoresSignalNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddExternalSemaphoresSignalNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddExternalSemaphoresSignalNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphExternalSemaphoresSignalNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
+    return cydriver._cuGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExternalSemaphoresSignalNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresWaitNode' in found_functions}}
 
 cdef CUresult cuGraphAddExternalSemaphoresWaitNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddExternalSemaphoresWaitNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddExternalSemaphoresWaitNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphExternalSemaphoresWaitNodeGetParams(CUgraphNode hNode, CUDA_EXT_SEM_WAIT_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
+    return cydriver._cuGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
 {{endif}}
 
 {{if 'cuGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExternalSemaphoresWaitNodeSetParams(CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddBatchMemOpNode' in found_functions}}
 
 cdef CUresult cuGraphAddBatchMemOpNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddBatchMemOpNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddBatchMemOpNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphBatchMemOpNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphBatchMemOpNodeGetParams(CUgraphNode hNode, CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphBatchMemOpNodeGetParams(hNode, nodeParams_out)
+    return cydriver._cuGraphBatchMemOpNodeGetParams(hNode, nodeParams_out)
 {{endif}}
 
 {{if 'cuGraphBatchMemOpNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphBatchMemOpNodeSetParams(CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphBatchMemOpNodeSetParams(hNode, nodeParams)
+    return cydriver._cuGraphBatchMemOpNodeSetParams(hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExecBatchMemOpNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecBatchMemOpNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_BATCH_MEM_OP_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecBatchMemOpNodeSetParams(hGraphExec, hNode, nodeParams)
+    return cydriver._cuGraphExecBatchMemOpNodeSetParams(hGraphExec, hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphAddMemAllocNode' in found_functions}}
 
 cdef CUresult cuGraphAddMemAllocNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUDA_MEM_ALLOC_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddMemAllocNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
+    return cydriver._cuGraphAddMemAllocNode(phGraphNode, hGraph, dependencies, numDependencies, nodeParams)
 {{endif}}
 
 {{if 'cuGraphMemAllocNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphMemAllocNodeGetParams(CUgraphNode hNode, CUDA_MEM_ALLOC_NODE_PARAMS* params_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemAllocNodeGetParams(hNode, params_out)
+    return cydriver._cuGraphMemAllocNodeGetParams(hNode, params_out)
 {{endif}}
 
 {{if 'cuGraphAddMemFreeNode' in found_functions}}
 
 cdef CUresult cuGraphAddMemFreeNode(CUgraphNode* phGraphNode, CUgraph hGraph, const CUgraphNode* dependencies, size_t numDependencies, CUdeviceptr dptr) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddMemFreeNode(phGraphNode, hGraph, dependencies, numDependencies, dptr)
+    return cydriver._cuGraphAddMemFreeNode(phGraphNode, hGraph, dependencies, numDependencies, dptr)
 {{endif}}
 
 {{if 'cuGraphMemFreeNodeGetParams' in found_functions}}
 
 cdef CUresult cuGraphMemFreeNodeGetParams(CUgraphNode hNode, CUdeviceptr* dptr_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphMemFreeNodeGetParams(hNode, dptr_out)
+    return cydriver._cuGraphMemFreeNodeGetParams(hNode, dptr_out)
 {{endif}}
 
 {{if 'cuDeviceGraphMemTrim' in found_functions}}
 
 cdef CUresult cuDeviceGraphMemTrim(CUdevice device) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGraphMemTrim(device)
+    return cydriver._cuDeviceGraphMemTrim(device)
 {{endif}}
 
 {{if 'cuDeviceGetGraphMemAttribute' in found_functions}}
 
 cdef CUresult cuDeviceGetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetGraphMemAttribute(device, attr, value)
+    return cydriver._cuDeviceGetGraphMemAttribute(device, attr, value)
 {{endif}}
 
 {{if 'cuDeviceSetGraphMemAttribute' in found_functions}}
 
 cdef CUresult cuDeviceSetGraphMemAttribute(CUdevice device, CUgraphMem_attribute attr, void* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceSetGraphMemAttribute(device, attr, value)
+    return cydriver._cuDeviceSetGraphMemAttribute(device, attr, value)
 {{endif}}
 
 {{if 'cuGraphClone' in found_functions}}
 
 cdef CUresult cuGraphClone(CUgraph* phGraphClone, CUgraph originalGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphClone(phGraphClone, originalGraph)
+    return cydriver._cuGraphClone(phGraphClone, originalGraph)
 {{endif}}
 
 {{if 'cuGraphNodeFindInClone' in found_functions}}
 
 cdef CUresult cuGraphNodeFindInClone(CUgraphNode* phNode, CUgraphNode hOriginalNode, CUgraph hClonedGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeFindInClone(phNode, hOriginalNode, hClonedGraph)
+    return cydriver._cuGraphNodeFindInClone(phNode, hOriginalNode, hClonedGraph)
 {{endif}}
 
 {{if 'cuGraphNodeGetType' in found_functions}}
 
 cdef CUresult cuGraphNodeGetType(CUgraphNode hNode, CUgraphNodeType* typename) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeGetType(hNode, typename)
+    return cydriver._cuGraphNodeGetType(hNode, typename)
 {{endif}}
 
 {{if 'cuGraphGetNodes' in found_functions}}
 
 cdef CUresult cuGraphGetNodes(CUgraph hGraph, CUgraphNode* nodes, size_t* numNodes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphGetNodes(hGraph, nodes, numNodes)
+    return cydriver._cuGraphGetNodes(hGraph, nodes, numNodes)
 {{endif}}
 
 {{if 'cuGraphGetRootNodes' in found_functions}}
 
 cdef CUresult cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode* rootNodes, size_t* numRootNodes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphGetRootNodes(hGraph, rootNodes, numRootNodes)
+    return cydriver._cuGraphGetRootNodes(hGraph, rootNodes, numRootNodes)
 {{endif}}
 
 {{if 'cuGraphGetEdges' in found_functions}}
 
 cdef CUresult cuGraphGetEdges(CUgraph hGraph, CUgraphNode* from_, CUgraphNode* to, size_t* numEdges) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphGetEdges(hGraph, from_, to, numEdges)
+    return cydriver._cuGraphGetEdges(hGraph, from_, to, numEdges)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependencies' in found_functions}}
 
 cdef CUresult cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode* dependencies, size_t* numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeGetDependencies(hNode, dependencies, numDependencies)
+    return cydriver._cuGraphNodeGetDependencies(hNode, dependencies, numDependencies)
 {{endif}}
 
 {{if 'cuGraphNodeGetDependentNodes' in found_functions}}
 
 cdef CUresult cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode* dependentNodes, size_t* numDependentNodes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeGetDependentNodes(hNode, dependentNodes, numDependentNodes)
+    return cydriver._cuGraphNodeGetDependentNodes(hNode, dependentNodes, numDependentNodes)
 {{endif}}
 
 {{if 'cuGraphAddDependencies' in found_functions}}
 
 cdef CUresult cuGraphAddDependencies(CUgraph hGraph, const CUgraphNode* from_, const CUgraphNode* to, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphAddDependencies(hGraph, from_, to, numDependencies)
+    return cydriver._cuGraphAddDependencies(hGraph, from_, to, numDependencies)
 {{endif}}
 
 {{if 'cuGraphRemoveDependencies' in found_functions}}
 
 cdef CUresult cuGraphRemoveDependencies(CUgraph hGraph, const CUgraphNode* from_, const CUgraphNode* to, size_t numDependencies) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphRemoveDependencies(hGraph, from_, to, numDependencies)
+    return cydriver._cuGraphRemoveDependencies(hGraph, from_, to, numDependencies)
 {{endif}}
 
 {{if 'cuGraphDestroyNode' in found_functions}}
 
 cdef CUresult cuGraphDestroyNode(CUgraphNode hNode) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphDestroyNode(hNode)
+    return cydriver._cuGraphDestroyNode(hNode)
 {{endif}}
 
 {{if 'cuGraphInstantiate_v2' in found_functions}}
 
 cdef CUresult cuGraphInstantiate(CUgraphExec* phGraphExec, CUgraph hGraph, CUgraphNode* phErrorNode, char* logBuffer, size_t bufferSize) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphInstantiate_v2(phGraphExec, hGraph, phErrorNode, logBuffer, bufferSize)
+    return cydriver._cuGraphInstantiate_v2(phGraphExec, hGraph, phErrorNode, logBuffer, bufferSize)
 {{endif}}
 
 {{if 'cuGraphInstantiateWithFlags' in found_functions}}
 
 cdef CUresult cuGraphInstantiateWithFlags(CUgraphExec* phGraphExec, CUgraph hGraph, unsigned long long flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphInstantiateWithFlags(phGraphExec, hGraph, flags)
+    return cydriver._cuGraphInstantiateWithFlags(phGraphExec, hGraph, flags)
 {{endif}}
 
 {{if 'cuGraphExecKernelNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_KERNEL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecKernelNodeSetParams(hGraphExec, hNode, nodeParams)
+    return cydriver._cuGraphExecKernelNodeSetParams(hGraphExec, hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExecMemcpyNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMCPY3D* copyParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecMemcpyNodeSetParams(hGraphExec, hNode, copyParams, ctx)
+    return cydriver._cuGraphExecMemcpyNodeSetParams(hGraphExec, hNode, copyParams, ctx)
 {{endif}}
 
 {{if 'cuGraphExecMemsetNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_MEMSET_NODE_PARAMS* memsetParams, CUcontext ctx) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams, ctx)
+    return cydriver._cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams, ctx)
 {{endif}}
 
 {{if 'cuGraphExecHostNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_HOST_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecHostNodeSetParams(hGraphExec, hNode, nodeParams)
+    return cydriver._cuGraphExecHostNodeSetParams(hGraphExec, hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExecChildGraphNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecChildGraphNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUgraph childGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecChildGraphNodeSetParams(hGraphExec, hNode, childGraph)
+    return cydriver._cuGraphExecChildGraphNodeSetParams(hGraphExec, hNode, childGraph)
 {{endif}}
 
 {{if 'cuGraphExecEventRecordNodeSetEvent' in found_functions}}
 
 cdef CUresult cuGraphExecEventRecordNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
+    return cydriver._cuGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
 {{endif}}
 
 {{if 'cuGraphExecEventWaitNodeSetEvent' in found_functions}}
 
 cdef CUresult cuGraphExecEventWaitNodeSetEvent(CUgraphExec hGraphExec, CUgraphNode hNode, CUevent event) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
+    return cydriver._cuGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
 {{endif}}
 
 {{if 'cuGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecExternalSemaphoresSignalNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
+    return cydriver._cuGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
 
 cdef CUresult cuGraphExecExternalSemaphoresWaitNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, const CUDA_EXT_SEM_WAIT_NODE_PARAMS* nodeParams) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
+    return cydriver._cuGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
 {{endif}}
 
 {{if 'cuGraphNodeSetEnabled' in found_functions}}
 
 cdef CUresult cuGraphNodeSetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int isEnabled) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
+    return cydriver._cuGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
 {{endif}}
 
 {{if 'cuGraphNodeGetEnabled' in found_functions}}
 
 cdef CUresult cuGraphNodeGetEnabled(CUgraphExec hGraphExec, CUgraphNode hNode, unsigned int* isEnabled) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
+    return cydriver._cuGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
 {{endif}}
 
 {{if 'cuGraphUpload' in found_functions}}
 
 cdef CUresult cuGraphUpload(CUgraphExec hGraphExec, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphUpload(hGraphExec, hStream)
+    return cydriver._cuGraphUpload(hGraphExec, hStream)
 {{endif}}
 
 {{if 'cuGraphLaunch' in found_functions}}
 
 cdef CUresult cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphLaunch(hGraphExec, hStream)
+    return cydriver._cuGraphLaunch(hGraphExec, hStream)
 {{endif}}
 
 {{if 'cuGraphExecDestroy' in found_functions}}
 
 cdef CUresult cuGraphExecDestroy(CUgraphExec hGraphExec) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecDestroy(hGraphExec)
+    return cydriver._cuGraphExecDestroy(hGraphExec)
 {{endif}}
 
 {{if 'cuGraphDestroy' in found_functions}}
 
 cdef CUresult cuGraphDestroy(CUgraph hGraph) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphDestroy(hGraph)
+    return cydriver._cuGraphDestroy(hGraph)
 {{endif}}
 
 {{if 'cuGraphExecUpdate' in found_functions}}
 
 cdef CUresult cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraphNode* hErrorNode_out, CUgraphExecUpdateResult* updateResult_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphExecUpdate(hGraphExec, hGraph, hErrorNode_out, updateResult_out)
+    return cydriver._cuGraphExecUpdate(hGraphExec, hGraph, hErrorNode_out, updateResult_out)
 {{endif}}
 
 {{if 'cuGraphKernelNodeCopyAttributes' in found_functions}}
 
 cdef CUresult cuGraphKernelNodeCopyAttributes(CUgraphNode dst, CUgraphNode src) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphKernelNodeCopyAttributes(dst, src)
+    return cydriver._cuGraphKernelNodeCopyAttributes(dst, src)
 {{endif}}
 
 {{if 'cuGraphKernelNodeGetAttribute' in found_functions}}
 
 cdef CUresult cuGraphKernelNodeGetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr, CUkernelNodeAttrValue* value_out) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphKernelNodeGetAttribute(hNode, attr, value_out)
+    return cydriver._cuGraphKernelNodeGetAttribute(hNode, attr, value_out)
 {{endif}}
 
 {{if 'cuGraphKernelNodeSetAttribute' in found_functions}}
 
 cdef CUresult cuGraphKernelNodeSetAttribute(CUgraphNode hNode, CUkernelNodeAttrID attr, const CUkernelNodeAttrValue* value) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphKernelNodeSetAttribute(hNode, attr, value)
+    return cydriver._cuGraphKernelNodeSetAttribute(hNode, attr, value)
 {{endif}}
 
 {{if 'cuGraphDebugDotPrint' in found_functions}}
 
 cdef CUresult cuGraphDebugDotPrint(CUgraph hGraph, const char* path, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphDebugDotPrint(hGraph, path, flags)
+    return cydriver._cuGraphDebugDotPrint(hGraph, path, flags)
 {{endif}}
 
 {{if 'cuUserObjectCreate' in found_functions}}
 
 cdef CUresult cuUserObjectCreate(CUuserObject* object_out, void* ptr, CUhostFn destroy, unsigned int initialRefcount, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
+    return cydriver._cuUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
 {{endif}}
 
 {{if 'cuUserObjectRetain' in found_functions}}
 
 cdef CUresult cuUserObjectRetain(CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuUserObjectRetain(object, count)
+    return cydriver._cuUserObjectRetain(object, count)
 {{endif}}
 
 {{if 'cuUserObjectRelease' in found_functions}}
 
 cdef CUresult cuUserObjectRelease(CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuUserObjectRelease(object, count)
+    return cydriver._cuUserObjectRelease(object, count)
 {{endif}}
 
 {{if 'cuGraphRetainUserObject' in found_functions}}
 
 cdef CUresult cuGraphRetainUserObject(CUgraph graph, CUuserObject object, unsigned int count, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphRetainUserObject(graph, object, count, flags)
+    return cydriver._cuGraphRetainUserObject(graph, object, count, flags)
 {{endif}}
 
 {{if 'cuGraphReleaseUserObject' in found_functions}}
 
 cdef CUresult cuGraphReleaseUserObject(CUgraph graph, CUuserObject object, unsigned int count) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphReleaseUserObject(graph, object, count)
+    return cydriver._cuGraphReleaseUserObject(graph, object, count)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}
 
 cdef CUresult cuOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
+    return cydriver._cuOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}
 
 cdef CUresult cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, CUfunction func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
+    return cydriver._cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialBlockSize' in found_functions}}
 
 cdef CUresult cuOccupancyMaxPotentialBlockSize(int* minGridSize, int* blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxPotentialBlockSize(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
+    return cydriver._cuOccupancyMaxPotentialBlockSize(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialBlockSizeWithFlags' in found_functions}}
 
 cdef CUresult cuOccupancyMaxPotentialBlockSizeWithFlags(int* minGridSize, int* blockSize, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, size_t dynamicSMemSize, int blockSizeLimit, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxPotentialBlockSizeWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
+    return cydriver._cuOccupancyMaxPotentialBlockSizeWithFlags(minGridSize, blockSize, func, blockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
 {{endif}}
 
 {{if 'cuOccupancyAvailableDynamicSMemPerBlock' in found_functions}}
 
 cdef CUresult cuOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, CUfunction func, int numBlocks, int blockSize) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
+    return cydriver._cuOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
 {{endif}}
 
 {{if 'cuOccupancyMaxPotentialClusterSize' in found_functions}}
 
 cdef CUresult cuOccupancyMaxPotentialClusterSize(int* clusterSize, CUfunction func, const CUlaunchConfig* config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxPotentialClusterSize(clusterSize, func, config)
+    return cydriver._cuOccupancyMaxPotentialClusterSize(clusterSize, func, config)
 {{endif}}
 
 {{if 'cuOccupancyMaxActiveClusters' in found_functions}}
 
 cdef CUresult cuOccupancyMaxActiveClusters(int* numClusters, CUfunction func, const CUlaunchConfig* config) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuOccupancyMaxActiveClusters(numClusters, func, config)
+    return cydriver._cuOccupancyMaxActiveClusters(numClusters, func, config)
 {{endif}}
 
 {{if 'cuTexRefSetArray' in found_functions}}
 
 cdef CUresult cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetArray(hTexRef, hArray, Flags)
+    return cydriver._cuTexRefSetArray(hTexRef, hArray, Flags)
 {{endif}}
 
 {{if 'cuTexRefSetMipmappedArray' in found_functions}}
 
 cdef CUresult cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetMipmappedArray(hTexRef, hMipmappedArray, Flags)
+    return cydriver._cuTexRefSetMipmappedArray(hTexRef, hMipmappedArray, Flags)
 {{endif}}
 
 {{if 'cuTexRefSetAddress_v2' in found_functions}}
 
 cdef CUresult cuTexRefSetAddress(size_t* ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, size_t numbytes) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetAddress_v2(ByteOffset, hTexRef, dptr, numbytes)
+    return cydriver._cuTexRefSetAddress_v2(ByteOffset, hTexRef, dptr, numbytes)
 {{endif}}
 
 {{if 'cuTexRefSetAddress2D_v3' in found_functions}}
 
 cdef CUresult cuTexRefSetAddress2D(CUtexref hTexRef, const CUDA_ARRAY_DESCRIPTOR* desc, CUdeviceptr dptr, size_t Pitch) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetAddress2D_v3(hTexRef, desc, dptr, Pitch)
+    return cydriver._cuTexRefSetAddress2D_v3(hTexRef, desc, dptr, Pitch)
 {{endif}}
 
 {{if 'cuTexRefSetFormat' in found_functions}}
 
 cdef CUresult cuTexRefSetFormat(CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetFormat(hTexRef, fmt, NumPackedComponents)
+    return cydriver._cuTexRefSetFormat(hTexRef, fmt, NumPackedComponents)
 {{endif}}
 
 {{if 'cuTexRefSetAddressMode' in found_functions}}
 
 cdef CUresult cuTexRefSetAddressMode(CUtexref hTexRef, int dim, CUaddress_mode am) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetAddressMode(hTexRef, dim, am)
+    return cydriver._cuTexRefSetAddressMode(hTexRef, dim, am)
 {{endif}}
 
 {{if 'cuTexRefSetFilterMode' in found_functions}}
 
 cdef CUresult cuTexRefSetFilterMode(CUtexref hTexRef, CUfilter_mode fm) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetFilterMode(hTexRef, fm)
+    return cydriver._cuTexRefSetFilterMode(hTexRef, fm)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapFilterMode' in found_functions}}
 
 cdef CUresult cuTexRefSetMipmapFilterMode(CUtexref hTexRef, CUfilter_mode fm) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetMipmapFilterMode(hTexRef, fm)
+    return cydriver._cuTexRefSetMipmapFilterMode(hTexRef, fm)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapLevelBias' in found_functions}}
 
 cdef CUresult cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetMipmapLevelBias(hTexRef, bias)
+    return cydriver._cuTexRefSetMipmapLevelBias(hTexRef, bias)
 {{endif}}
 
 {{if 'cuTexRefSetMipmapLevelClamp' in found_functions}}
 
 cdef CUresult cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetMipmapLevelClamp(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
+    return cydriver._cuTexRefSetMipmapLevelClamp(hTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
 {{endif}}
 
 {{if 'cuTexRefSetMaxAnisotropy' in found_functions}}
 
 cdef CUresult cuTexRefSetMaxAnisotropy(CUtexref hTexRef, unsigned int maxAniso) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetMaxAnisotropy(hTexRef, maxAniso)
+    return cydriver._cuTexRefSetMaxAnisotropy(hTexRef, maxAniso)
 {{endif}}
 
 {{if 'cuTexRefSetBorderColor' in found_functions}}
 
 cdef CUresult cuTexRefSetBorderColor(CUtexref hTexRef, float* pBorderColor) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetBorderColor(hTexRef, pBorderColor)
+    return cydriver._cuTexRefSetBorderColor(hTexRef, pBorderColor)
 {{endif}}
 
 {{if 'cuTexRefSetFlags' in found_functions}}
 
 cdef CUresult cuTexRefSetFlags(CUtexref hTexRef, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefSetFlags(hTexRef, Flags)
+    return cydriver._cuTexRefSetFlags(hTexRef, Flags)
 {{endif}}
 
 {{if 'cuTexRefGetAddress_v2' in found_functions}}
 
 cdef CUresult cuTexRefGetAddress(CUdeviceptr* pdptr, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetAddress_v2(pdptr, hTexRef)
+    return cydriver._cuTexRefGetAddress_v2(pdptr, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetArray' in found_functions}}
 
 cdef CUresult cuTexRefGetArray(CUarray* phArray, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetArray(phArray, hTexRef)
+    return cydriver._cuTexRefGetArray(phArray, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetMipmappedArray' in found_functions}}
 
 cdef CUresult cuTexRefGetMipmappedArray(CUmipmappedArray* phMipmappedArray, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetMipmappedArray(phMipmappedArray, hTexRef)
+    return cydriver._cuTexRefGetMipmappedArray(phMipmappedArray, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetAddressMode' in found_functions}}
 
 cdef CUresult cuTexRefGetAddressMode(CUaddress_mode* pam, CUtexref hTexRef, int dim) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetAddressMode(pam, hTexRef, dim)
+    return cydriver._cuTexRefGetAddressMode(pam, hTexRef, dim)
 {{endif}}
 
 {{if 'cuTexRefGetFilterMode' in found_functions}}
 
 cdef CUresult cuTexRefGetFilterMode(CUfilter_mode* pfm, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetFilterMode(pfm, hTexRef)
+    return cydriver._cuTexRefGetFilterMode(pfm, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetFormat' in found_functions}}
 
 cdef CUresult cuTexRefGetFormat(CUarray_format* pFormat, int* pNumChannels, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetFormat(pFormat, pNumChannels, hTexRef)
+    return cydriver._cuTexRefGetFormat(pFormat, pNumChannels, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetMipmapFilterMode' in found_functions}}
 
 cdef CUresult cuTexRefGetMipmapFilterMode(CUfilter_mode* pfm, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetMipmapFilterMode(pfm, hTexRef)
+    return cydriver._cuTexRefGetMipmapFilterMode(pfm, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetMipmapLevelBias' in found_functions}}
 
 cdef CUresult cuTexRefGetMipmapLevelBias(float* pbias, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetMipmapLevelBias(pbias, hTexRef)
+    return cydriver._cuTexRefGetMipmapLevelBias(pbias, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetMipmapLevelClamp' in found_functions}}
 
 cdef CUresult cuTexRefGetMipmapLevelClamp(float* pminMipmapLevelClamp, float* pmaxMipmapLevelClamp, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetMipmapLevelClamp(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef)
+    return cydriver._cuTexRefGetMipmapLevelClamp(pminMipmapLevelClamp, pmaxMipmapLevelClamp, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetMaxAnisotropy' in found_functions}}
 
 cdef CUresult cuTexRefGetMaxAnisotropy(int* pmaxAniso, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetMaxAnisotropy(pmaxAniso, hTexRef)
+    return cydriver._cuTexRefGetMaxAnisotropy(pmaxAniso, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetBorderColor' in found_functions}}
 
 cdef CUresult cuTexRefGetBorderColor(float* pBorderColor, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetBorderColor(pBorderColor, hTexRef)
+    return cydriver._cuTexRefGetBorderColor(pBorderColor, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefGetFlags' in found_functions}}
 
 cdef CUresult cuTexRefGetFlags(unsigned int* pFlags, CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefGetFlags(pFlags, hTexRef)
+    return cydriver._cuTexRefGetFlags(pFlags, hTexRef)
 {{endif}}
 
 {{if 'cuTexRefCreate' in found_functions}}
 
 cdef CUresult cuTexRefCreate(CUtexref* pTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefCreate(pTexRef)
+    return cydriver._cuTexRefCreate(pTexRef)
 {{endif}}
 
 {{if 'cuTexRefDestroy' in found_functions}}
 
 cdef CUresult cuTexRefDestroy(CUtexref hTexRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexRefDestroy(hTexRef)
+    return cydriver._cuTexRefDestroy(hTexRef)
 {{endif}}
 
 {{if 'cuSurfRefSetArray' in found_functions}}
 
 cdef CUresult cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSurfRefSetArray(hSurfRef, hArray, Flags)
+    return cydriver._cuSurfRefSetArray(hSurfRef, hArray, Flags)
 {{endif}}
 
 {{if 'cuSurfRefGetArray' in found_functions}}
 
 cdef CUresult cuSurfRefGetArray(CUarray* phArray, CUsurfref hSurfRef) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSurfRefGetArray(phArray, hSurfRef)
+    return cydriver._cuSurfRefGetArray(phArray, hSurfRef)
 {{endif}}
 
 {{if 'cuTexObjectCreate' in found_functions}}
 
 cdef CUresult cuTexObjectCreate(CUtexObject* pTexObject, const CUDA_RESOURCE_DESC* pResDesc, const CUDA_TEXTURE_DESC* pTexDesc, const CUDA_RESOURCE_VIEW_DESC* pResViewDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexObjectCreate(pTexObject, pResDesc, pTexDesc, pResViewDesc)
+    return cydriver._cuTexObjectCreate(pTexObject, pResDesc, pTexDesc, pResViewDesc)
 {{endif}}
 
 {{if 'cuTexObjectDestroy' in found_functions}}
 
 cdef CUresult cuTexObjectDestroy(CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexObjectDestroy(texObject)
+    return cydriver._cuTexObjectDestroy(texObject)
 {{endif}}
 
 {{if 'cuTexObjectGetResourceDesc' in found_functions}}
 
 cdef CUresult cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexObjectGetResourceDesc(pResDesc, texObject)
+    return cydriver._cuTexObjectGetResourceDesc(pResDesc, texObject)
 {{endif}}
 
 {{if 'cuTexObjectGetTextureDesc' in found_functions}}
 
 cdef CUresult cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC* pTexDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexObjectGetTextureDesc(pTexDesc, texObject)
+    return cydriver._cuTexObjectGetTextureDesc(pTexDesc, texObject)
 {{endif}}
 
 {{if 'cuTexObjectGetResourceViewDesc' in found_functions}}
 
 cdef CUresult cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC* pResViewDesc, CUtexObject texObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuTexObjectGetResourceViewDesc(pResViewDesc, texObject)
+    return cydriver._cuTexObjectGetResourceViewDesc(pResViewDesc, texObject)
 {{endif}}
 
 {{if 'cuSurfObjectCreate' in found_functions}}
 
 cdef CUresult cuSurfObjectCreate(CUsurfObject* pSurfObject, const CUDA_RESOURCE_DESC* pResDesc) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSurfObjectCreate(pSurfObject, pResDesc)
+    return cydriver._cuSurfObjectCreate(pSurfObject, pResDesc)
 {{endif}}
 
 {{if 'cuSurfObjectDestroy' in found_functions}}
 
 cdef CUresult cuSurfObjectDestroy(CUsurfObject surfObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSurfObjectDestroy(surfObject)
+    return cydriver._cuSurfObjectDestroy(surfObject)
 {{endif}}
 
 {{if 'cuSurfObjectGetResourceDesc' in found_functions}}
 
 cdef CUresult cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC* pResDesc, CUsurfObject surfObject) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuSurfObjectGetResourceDesc(pResDesc, surfObject)
+    return cydriver._cuSurfObjectGetResourceDesc(pResDesc, surfObject)
 {{endif}}
 
 {{if 'cuDeviceCanAccessPeer' in found_functions}}
 
 cdef CUresult cuDeviceCanAccessPeer(int* canAccessPeer, CUdevice dev, CUdevice peerDev) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceCanAccessPeer(canAccessPeer, dev, peerDev)
+    return cydriver._cuDeviceCanAccessPeer(canAccessPeer, dev, peerDev)
 {{endif}}
 
 {{if 'cuCtxEnablePeerAccess' in found_functions}}
 
 cdef CUresult cuCtxEnablePeerAccess(CUcontext peerContext, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxEnablePeerAccess(peerContext, Flags)
+    return cydriver._cuCtxEnablePeerAccess(peerContext, Flags)
 {{endif}}
 
 {{if 'cuCtxDisablePeerAccess' in found_functions}}
 
 cdef CUresult cuCtxDisablePeerAccess(CUcontext peerContext) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuCtxDisablePeerAccess(peerContext)
+    return cydriver._cuCtxDisablePeerAccess(peerContext)
 {{endif}}
 
 {{if 'cuDeviceGetP2PAttribute' in found_functions}}
 
 cdef CUresult cuDeviceGetP2PAttribute(int* value, CUdevice_P2PAttribute attrib, CUdevice srcDevice, CUdevice dstDevice) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuDeviceGetP2PAttribute(value, attrib, srcDevice, dstDevice)
+    return cydriver._cuDeviceGetP2PAttribute(value, attrib, srcDevice, dstDevice)
 {{endif}}
 
 {{if 'cuGraphicsUnregisterResource' in found_functions}}
 
 cdef CUresult cuGraphicsUnregisterResource(CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsUnregisterResource(resource)
+    return cydriver._cuGraphicsUnregisterResource(resource)
 {{endif}}
 
 {{if 'cuGraphicsSubResourceGetMappedArray' in found_functions}}
 
 cdef CUresult cuGraphicsSubResourceGetMappedArray(CUarray* pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsSubResourceGetMappedArray(pArray, resource, arrayIndex, mipLevel)
+    return cydriver._cuGraphicsSubResourceGetMappedArray(pArray, resource, arrayIndex, mipLevel)
 {{endif}}
 
 {{if 'cuGraphicsResourceGetMappedMipmappedArray' in found_functions}}
 
 cdef CUresult cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray* pMipmappedArray, CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsResourceGetMappedMipmappedArray(pMipmappedArray, resource)
+    return cydriver._cuGraphicsResourceGetMappedMipmappedArray(pMipmappedArray, resource)
 {{endif}}
 
 {{if 'cuGraphicsResourceGetMappedPointer_v2' in found_functions}}
 
 cdef CUresult cuGraphicsResourceGetMappedPointer(CUdeviceptr* pDevPtr, size_t* pSize, CUgraphicsResource resource) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsResourceGetMappedPointer_v2(pDevPtr, pSize, resource)
+    return cydriver._cuGraphicsResourceGetMappedPointer_v2(pDevPtr, pSize, resource)
 {{endif}}
 
 {{if 'cuGraphicsResourceSetMapFlags_v2' in found_functions}}
 
 cdef CUresult cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsResourceSetMapFlags_v2(resource, flags)
+    return cydriver._cuGraphicsResourceSetMapFlags_v2(resource, flags)
 {{endif}}
 
 {{if 'cuGraphicsMapResources' in found_functions}}
 
 cdef CUresult cuGraphicsMapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsMapResources(count, resources, hStream)
+    return cydriver._cuGraphicsMapResources(count, resources, hStream)
 {{endif}}
 
 {{if 'cuGraphicsUnmapResources' in found_functions}}
 
 cdef CUresult cuGraphicsUnmapResources(unsigned int count, CUgraphicsResource* resources, CUstream hStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsUnmapResources(count, resources, hStream)
+    return cydriver._cuGraphicsUnmapResources(count, resources, hStream)
 {{endif}}
 
 {{if 'cuGetProcAddress' in found_functions}}
 
 cdef CUresult cuGetProcAddress(const char* symbol, void** pfn, int cudaVersion, cuuint64_t flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGetProcAddress(symbol, pfn, cudaVersion, flags)
+    return cydriver._cuGetProcAddress(symbol, pfn, cudaVersion, flags)
 {{endif}}
 
 {{if 'cuGetExportTable' in found_functions}}
 
 cdef CUresult cuGetExportTable(const void** ppExportTable, const CUuuid* pExportTableId) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGetExportTable(ppExportTable, pExportTableId)
+    return cydriver._cuGetExportTable(ppExportTable, pExportTableId)
 {{endif}}
 
 {{if 'cuProfilerInitialize' in found_functions}}
 
 cdef CUresult cuProfilerInitialize(const char* configFile, const char* outputFile, CUoutput_mode outputMode) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuProfilerInitialize(configFile, outputFile, outputMode)
+    return cydriver._cuProfilerInitialize(configFile, outputFile, outputMode)
 {{endif}}
 
 {{if 'cuProfilerStart' in found_functions}}
 
 cdef CUresult cuProfilerStart() except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuProfilerStart()
+    return cydriver._cuProfilerStart()
 {{endif}}
 
 {{if 'cuProfilerStop' in found_functions}}
 
 cdef CUresult cuProfilerStop() except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuProfilerStop()
+    return cydriver._cuProfilerStop()
 {{endif}}
 
-{{if True or 'cuVDPAUGetDevice' in found_functions}}
-
-cdef CUresult cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuVDPAUGetDevice(pDevice, vdpDevice, vdpGetProcAddress)
-{{endif}}
-
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
-
-cdef CUresult cuVDPAUCtxCreate(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuVDPAUCtxCreate_v2(pCtx, flags, device, vdpDevice, vdpGetProcAddress)
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsVDPAURegisterVideoSurface(pCudaResource, vdpSurface, flags)
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsVDPAURegisterOutputSurface(pCudaResource, vdpSurface, flags)
-{{endif}}
-
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsEGLRegisterImage(CUgraphicsResource* pCudaResource, EGLImageKHR image, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsEGLRegisterImage(pCudaResource, image, flags)
+    return cydriver._cuGraphicsEGLRegisterImage(pCudaResource, image, flags)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamConsumerConnect(conn, stream)
+    return cydriver._cuEGLStreamConsumerConnect(conn, stream)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerConnectWithFlags(CUeglStreamConnection* conn, EGLStreamKHR stream, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamConsumerConnectWithFlags(conn, stream, flags)
+    return cydriver._cuEGLStreamConsumerConnectWithFlags(conn, stream, flags)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamConsumerDisconnect(conn)
+    return cydriver._cuEGLStreamConsumerDisconnect(conn)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerAcquireFrame(CUeglStreamConnection* conn, CUgraphicsResource* pCudaResource, CUstream* pStream, unsigned int timeout) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)
+    return cydriver._cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamConsumerReleaseFrame(CUeglStreamConnection* conn, CUgraphicsResource pCudaResource, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)
+    return cydriver._cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerConnect(CUeglStreamConnection* conn, EGLStreamKHR stream, EGLint width, EGLint height) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamProducerConnect(conn, stream, width, height)
+    return cydriver._cuEGLStreamProducerConnect(conn, stream, width, height)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerDisconnect(CUeglStreamConnection* conn) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamProducerDisconnect(conn)
+    return cydriver._cuEGLStreamProducerDisconnect(conn)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerPresentFrame(CUeglStreamConnection* conn, CUeglFrame eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamProducerPresentFrame(conn, eglframe, pStream)
+    return cydriver._cuEGLStreamProducerPresentFrame(conn, eglframe, pStream)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEGLStreamProducerReturnFrame(CUeglStreamConnection* conn, CUeglFrame* eglframe, CUstream* pStream) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEGLStreamProducerReturnFrame(conn, eglframe, pStream)
+    return cydriver._cuEGLStreamProducerReturnFrame(conn, eglframe, pStream)
 {{endif}}
 
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsResourceGetMappedEglFrame(CUeglFrame* eglFrame, CUgraphicsResource resource, unsigned int index, unsigned int mipLevel) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)
+    return cydriver._cuGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)
 {{endif}}
 
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 cdef CUresult cuEventCreateFromEGLSync(CUevent* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuEventCreateFromEGLSync(phEvent, eglSync, flags)
+    return cydriver._cuEventCreateFromEGLSync(phEvent, eglSync, flags)
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsGLRegisterBuffer(CUgraphicsResource* pCudaResource, GLuint buffer, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsGLRegisterBuffer(pCudaResource, buffer, Flags)
+    return cydriver._cuGraphicsGLRegisterBuffer(pCudaResource, buffer, Flags)
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGraphicsGLRegisterImage(CUgraphicsResource* pCudaResource, GLuint image, GLenum target, unsigned int Flags) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGraphicsGLRegisterImage(pCudaResource, image, target, Flags)
+    return cydriver._cuGraphicsGLRegisterImage(pCudaResource, image, target, Flags)
 {{endif}}
 
-{{if True or 'cuGLGetDevices_v2' in found_functions}}
+{{if True}}
 
 cdef CUresult cuGLGetDevices(unsigned int* pCudaDeviceCount, CUdevice* pCudaDevices, unsigned int cudaDeviceCount, CUGLDeviceList deviceList) except ?CUDA_ERROR_NOT_FOUND nogil:
-    return ccuda._cuGLGetDevices_v2(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+    return cydriver._cuGLGetDevices_v2(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+{{endif}}
+
+{{if True}}
+
+cdef CUresult cuVDPAUGetDevice(CUdevice* pDevice, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
+    return cydriver._cuVDPAUGetDevice(pDevice, vdpDevice, vdpGetProcAddress)
+{{endif}}
+
+{{if True}}
+
+cdef CUresult cuVDPAUCtxCreate(CUcontext* pCtx, unsigned int flags, CUdevice device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?CUDA_ERROR_NOT_FOUND nogil:
+    return cydriver._cuVDPAUCtxCreate_v2(pCtx, flags, device, vdpDevice, vdpGetProcAddress)
+{{endif}}
+
+{{if True}}
+
+cdef CUresult cuGraphicsVDPAURegisterVideoSurface(CUgraphicsResource* pCudaResource, VdpVideoSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
+    return cydriver._cuGraphicsVDPAURegisterVideoSurface(pCudaResource, vdpSurface, flags)
+{{endif}}
+
+{{if True}}
+
+cdef CUresult cuGraphicsVDPAURegisterOutputSurface(CUgraphicsResource* pCudaResource, VdpOutputSurface vdpSurface, unsigned int flags) except ?CUDA_ERROR_NOT_FOUND nogil:
+    return cydriver._cuGraphicsVDPAURegisterOutputSurface(pCudaResource, vdpSurface, flags)
 {{endif}}
diff --git a/cuda/cnvrtc.pxd.in b/cuda/cuda/bindings/cynvrtc.pxd.in
similarity index 97%
rename from cuda/cnvrtc.pxd.in
rename to cuda/cuda/bindings/cynvrtc.pxd.in
index b80f7fd0..55a7022b 100644
--- a/cuda/cnvrtc.pxd.in
+++ b/cuda/cuda/bindings/cynvrtc.pxd.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -6,6 +6,8 @@
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
 
+from libc.stdint cimport uint32_t, uint64_t
+
 cdef extern from "nvrtc.h":
 
     ctypedef enum nvrtcResult:
@@ -110,3 +112,4 @@ cdef nvrtcResult nvrtcAddNameExpression(nvrtcProgram prog, const char* name_expr
 
 cdef nvrtcResult nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expression, const char** lowered_name) except ?NVRTC_ERROR_INVALID_INPUT nogil
 {{endif}}
+
diff --git a/cuda/cnvrtc.pyx.in b/cuda/cuda/bindings/cynvrtc.pyx.in
similarity index 75%
rename from cuda/cnvrtc.pyx.in
rename to cuda/cuda/bindings/cynvrtc.pyx.in
index 9712854b..bf958309 100644
--- a/cuda/cnvrtc.pyx.in
+++ b/cuda/cuda/bindings/cynvrtc.pyx.in
@@ -1,110 +1,110 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda._cuda.cnvrtc as cnvrtc
+cimport cuda.bindings._bindings.cynvrtc as cynvrtc
 
 {{if 'nvrtcGetErrorString' in found_functions}}
 
 cdef const char* nvrtcGetErrorString(nvrtcResult result) except ?NULL nogil:
-    return cnvrtc._nvrtcGetErrorString(result)
+    return cynvrtc._nvrtcGetErrorString(result)
 {{endif}}
 
 {{if 'nvrtcVersion' in found_functions}}
 
 cdef nvrtcResult nvrtcVersion(int* major, int* minor) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcVersion(major, minor)
+    return cynvrtc._nvrtcVersion(major, minor)
 {{endif}}
 
 {{if 'nvrtcGetNumSupportedArchs' in found_functions}}
 
 cdef nvrtcResult nvrtcGetNumSupportedArchs(int* numArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetNumSupportedArchs(numArchs)
+    return cynvrtc._nvrtcGetNumSupportedArchs(numArchs)
 {{endif}}
 
 {{if 'nvrtcGetSupportedArchs' in found_functions}}
 
 cdef nvrtcResult nvrtcGetSupportedArchs(int* supportedArchs) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetSupportedArchs(supportedArchs)
+    return cynvrtc._nvrtcGetSupportedArchs(supportedArchs)
 {{endif}}
 
 {{if 'nvrtcCreateProgram' in found_functions}}
 
 cdef nvrtcResult nvrtcCreateProgram(nvrtcProgram* prog, const char* src, const char* name, int numHeaders, const char** headers, const char** includeNames) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcCreateProgram(prog, src, name, numHeaders, headers, includeNames)
+    return cynvrtc._nvrtcCreateProgram(prog, src, name, numHeaders, headers, includeNames)
 {{endif}}
 
 {{if 'nvrtcDestroyProgram' in found_functions}}
 
 cdef nvrtcResult nvrtcDestroyProgram(nvrtcProgram* prog) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcDestroyProgram(prog)
+    return cynvrtc._nvrtcDestroyProgram(prog)
 {{endif}}
 
 {{if 'nvrtcCompileProgram' in found_functions}}
 
 cdef nvrtcResult nvrtcCompileProgram(nvrtcProgram prog, int numOptions, const char** options) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcCompileProgram(prog, numOptions, options)
+    return cynvrtc._nvrtcCompileProgram(prog, numOptions, options)
 {{endif}}
 
 {{if 'nvrtcGetPTXSize' in found_functions}}
 
 cdef nvrtcResult nvrtcGetPTXSize(nvrtcProgram prog, size_t* ptxSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetPTXSize(prog, ptxSizeRet)
+    return cynvrtc._nvrtcGetPTXSize(prog, ptxSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetPTX' in found_functions}}
 
 cdef nvrtcResult nvrtcGetPTX(nvrtcProgram prog, char* ptx) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetPTX(prog, ptx)
+    return cynvrtc._nvrtcGetPTX(prog, ptx)
 {{endif}}
 
 {{if 'nvrtcGetCUBINSize' in found_functions}}
 
 cdef nvrtcResult nvrtcGetCUBINSize(nvrtcProgram prog, size_t* cubinSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetCUBINSize(prog, cubinSizeRet)
+    return cynvrtc._nvrtcGetCUBINSize(prog, cubinSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetCUBIN' in found_functions}}
 
 cdef nvrtcResult nvrtcGetCUBIN(nvrtcProgram prog, char* cubin) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetCUBIN(prog, cubin)
+    return cynvrtc._nvrtcGetCUBIN(prog, cubin)
 {{endif}}
 
 {{if 'nvrtcGetNVVMSize' in found_functions}}
 
 cdef nvrtcResult nvrtcGetNVVMSize(nvrtcProgram prog, size_t* nvvmSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetNVVMSize(prog, nvvmSizeRet)
+    return cynvrtc._nvrtcGetNVVMSize(prog, nvvmSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetNVVM' in found_functions}}
 
 cdef nvrtcResult nvrtcGetNVVM(nvrtcProgram prog, char* nvvm) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetNVVM(prog, nvvm)
+    return cynvrtc._nvrtcGetNVVM(prog, nvvm)
 {{endif}}
 
 {{if 'nvrtcGetProgramLogSize' in found_functions}}
 
 cdef nvrtcResult nvrtcGetProgramLogSize(nvrtcProgram prog, size_t* logSizeRet) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetProgramLogSize(prog, logSizeRet)
+    return cynvrtc._nvrtcGetProgramLogSize(prog, logSizeRet)
 {{endif}}
 
 {{if 'nvrtcGetProgramLog' in found_functions}}
 
 cdef nvrtcResult nvrtcGetProgramLog(nvrtcProgram prog, char* log) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetProgramLog(prog, log)
+    return cynvrtc._nvrtcGetProgramLog(prog, log)
 {{endif}}
 
 {{if 'nvrtcAddNameExpression' in found_functions}}
 
 cdef nvrtcResult nvrtcAddNameExpression(nvrtcProgram prog, const char* name_expression) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcAddNameExpression(prog, name_expression)
+    return cynvrtc._nvrtcAddNameExpression(prog, name_expression)
 {{endif}}
 
 {{if 'nvrtcGetLoweredName' in found_functions}}
 
 cdef nvrtcResult nvrtcGetLoweredName(nvrtcProgram prog, const char* name_expression, const char** lowered_name) except ?NVRTC_ERROR_INVALID_INPUT nogil:
-    return cnvrtc._nvrtcGetLoweredName(prog, name_expression, lowered_name)
+    return cynvrtc._nvrtcGetLoweredName(prog, name_expression, lowered_name)
 {{endif}}
diff --git a/cuda/ccudart.pxd.in b/cuda/cuda/bindings/cyruntime.pxd.in
similarity index 94%
rename from cuda/ccudart.pxd.in
rename to cuda/cuda/bindings/cyruntime.pxd.in
index eacda429..b543ced4 100644
--- a/cuda/ccudart.pxd.in
+++ b/cuda/cuda/bindings/cyruntime.pxd.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -6,13 +6,17 @@
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
 
-cdef extern from "driver_types.h":
+from libc.stdint cimport uint32_t, uint64_t
+
+cdef extern from "vector_types.h":
 
     cdef struct dim3:
         unsigned int x
         unsigned int y
         unsigned int z
 
+cdef extern from "driver_types.h":
+
     cdef enum cudaError:
         cudaSuccess = 0
         cudaErrorInvalidValue = 1
@@ -140,38 +144,13 @@ cdef extern from "driver_types.h":
         cudaErrorUnknown = 999
         cudaErrorApiFailureBase = 10000
 
-    cdef enum cudaChannelFormatKind:
-        cudaChannelFormatKindSigned = 0
-        cudaChannelFormatKindUnsigned = 1
-        cudaChannelFormatKindFloat = 2
-        cudaChannelFormatKindNone = 3
-        cudaChannelFormatKindNV12 = 4
-        cudaChannelFormatKindUnsignedNormalized8X1 = 5
-        cudaChannelFormatKindUnsignedNormalized8X2 = 6
-        cudaChannelFormatKindUnsignedNormalized8X4 = 7
-        cudaChannelFormatKindUnsignedNormalized16X1 = 8
-        cudaChannelFormatKindUnsignedNormalized16X2 = 9
-        cudaChannelFormatKindUnsignedNormalized16X4 = 10
-        cudaChannelFormatKindSignedNormalized8X1 = 11
-        cudaChannelFormatKindSignedNormalized8X2 = 12
-        cudaChannelFormatKindSignedNormalized8X4 = 13
-        cudaChannelFormatKindSignedNormalized16X1 = 14
-        cudaChannelFormatKindSignedNormalized16X2 = 15
-        cudaChannelFormatKindSignedNormalized16X4 = 16
-        cudaChannelFormatKindUnsignedBlockCompressed1 = 17
-        cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18
-        cudaChannelFormatKindUnsignedBlockCompressed2 = 19
-        cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20
-        cudaChannelFormatKindUnsignedBlockCompressed3 = 21
-        cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22
-        cudaChannelFormatKindUnsignedBlockCompressed4 = 23
-        cudaChannelFormatKindSignedBlockCompressed4 = 24
-        cudaChannelFormatKindUnsignedBlockCompressed5 = 25
-        cudaChannelFormatKindSignedBlockCompressed5 = 26
-        cudaChannelFormatKindUnsignedBlockCompressed6H = 27
-        cudaChannelFormatKindSignedBlockCompressed6H = 28
-        cudaChannelFormatKindUnsignedBlockCompressed7 = 29
-        cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30
+    ctypedef cudaError cudaError_t
+
+    cdef enum cudaOutputMode:
+        cudaKeyValuePair = 0
+        cudaCSV = 1
+
+    ctypedef cudaOutputMode cudaOutputMode_t
 
     cdef struct cudaChannelFormatDesc:
         int x
@@ -188,7 +167,6 @@ cdef extern from "driver_types.h":
         pass
     ctypedef cudaArray* cudaArray_const_t
 
-    
     cdef struct cudaMipmappedArray:
         pass
     ctypedef cudaMipmappedArray* cudaMipmappedArray_t
@@ -197,14 +175,13 @@ cdef extern from "driver_types.h":
         pass
     ctypedef cudaMipmappedArray* cudaMipmappedArray_const_t
 
-    
-    cdef struct _cudaArraySparseProperties_tileExtent_s:
+    cdef struct anon_struct0:
         unsigned int width
         unsigned int height
         unsigned int depth
 
     cdef struct cudaArraySparseProperties:
-        _cudaArraySparseProperties_tileExtent_s tileExtent
+        anon_struct0 tileExtent
         unsigned int miptailFirstLevel
         unsigned long long miptailSize
         unsigned int flags
@@ -215,19 +192,6 @@ cdef extern from "driver_types.h":
         size_t alignment
         unsigned int reserved[4]
 
-    cdef enum cudaMemoryType:
-        cudaMemoryTypeUnregistered = 0
-        cudaMemoryTypeHost = 1
-        cudaMemoryTypeDevice = 2
-        cudaMemoryTypeManaged = 3
-
-    cdef enum cudaMemcpyKind:
-        cudaMemcpyHostToHost = 0
-        cudaMemcpyHostToDevice = 1
-        cudaMemcpyDeviceToHost = 2
-        cudaMemcpyDeviceToDevice = 3
-        cudaMemcpyDefault = 4
-
     cdef struct cudaPitchedPtr:
         void* ptr
         size_t pitch
@@ -273,11 +237,6 @@ cdef extern from "driver_types.h":
         size_t width
         size_t height
 
-    cdef enum cudaAccessProperty:
-        cudaAccessPropertyNormal = 0
-        cudaAccessPropertyStreaming = 1
-        cudaAccessPropertyPersisting = 2
-
     cdef struct cudaAccessPolicyWindow:
         void* base_ptr
         size_t num_bytes
@@ -291,128 +250,33 @@ cdef extern from "driver_types.h":
         cudaHostFn_t fn
         void* userData
 
-    cdef enum cudaStreamCaptureStatus:
-        cudaStreamCaptureStatusNone = 0
-        cudaStreamCaptureStatusActive = 1
-        cudaStreamCaptureStatusInvalidated = 2
-
-    cdef enum cudaStreamCaptureMode:
-        cudaStreamCaptureModeGlobal = 0
-        cudaStreamCaptureModeThreadLocal = 1
-        cudaStreamCaptureModeRelaxed = 2
-
-    cdef enum cudaSynchronizationPolicy:
-        cudaSyncPolicyAuto = 1
-        cudaSyncPolicySpin = 2
-        cudaSyncPolicyYield = 3
-        cudaSyncPolicyBlockingSync = 4
-
-    cdef enum cudaClusterSchedulingPolicy:
-        cudaClusterSchedulingPolicyDefault = 0
-        cudaClusterSchedulingPolicySpread = 1
-        cudaClusterSchedulingPolicyLoadBalancing = 2
-
-    cdef enum cudaStreamUpdateCaptureDependenciesFlags:
-        cudaStreamAddCaptureDependencies = 0
-        cudaStreamSetCaptureDependencies = 1
-
-    cdef enum cudaUserObjectFlags:
-        cudaUserObjectNoDestructorSync = 1
-
-    cdef enum cudaUserObjectRetainFlags:
-        cudaGraphUserObjectMove = 1
-
-    
-    cdef enum cudaGraphicsRegisterFlags:
-        cudaGraphicsRegisterFlagsNone = 0
-        cudaGraphicsRegisterFlagsReadOnly = 1
-        cudaGraphicsRegisterFlagsWriteDiscard = 2
-        cudaGraphicsRegisterFlagsSurfaceLoadStore = 4
-        cudaGraphicsRegisterFlagsTextureGather = 8
-
-    cdef enum cudaGraphicsMapFlags:
-        cudaGraphicsMapFlagsNone = 0
-        cudaGraphicsMapFlagsReadOnly = 1
-        cudaGraphicsMapFlagsWriteDiscard = 2
-
-    cdef enum cudaGraphicsCubeFace:
-        cudaGraphicsCubeFacePositiveX = 0
-        cudaGraphicsCubeFaceNegativeX = 1
-        cudaGraphicsCubeFacePositiveY = 2
-        cudaGraphicsCubeFaceNegativeY = 3
-        cudaGraphicsCubeFacePositiveZ = 4
-        cudaGraphicsCubeFaceNegativeZ = 5
-
-    cdef enum cudaResourceType:
-        cudaResourceTypeArray = 0
-        cudaResourceTypeMipmappedArray = 1
-        cudaResourceTypeLinear = 2
-        cudaResourceTypePitch2D = 3
-
-    cdef enum cudaResourceViewFormat:
-        cudaResViewFormatNone = 0
-        cudaResViewFormatUnsignedChar1 = 1
-        cudaResViewFormatUnsignedChar2 = 2
-        cudaResViewFormatUnsignedChar4 = 3
-        cudaResViewFormatSignedChar1 = 4
-        cudaResViewFormatSignedChar2 = 5
-        cudaResViewFormatSignedChar4 = 6
-        cudaResViewFormatUnsignedShort1 = 7
-        cudaResViewFormatUnsignedShort2 = 8
-        cudaResViewFormatUnsignedShort4 = 9
-        cudaResViewFormatSignedShort1 = 10
-        cudaResViewFormatSignedShort2 = 11
-        cudaResViewFormatSignedShort4 = 12
-        cudaResViewFormatUnsignedInt1 = 13
-        cudaResViewFormatUnsignedInt2 = 14
-        cudaResViewFormatUnsignedInt4 = 15
-        cudaResViewFormatSignedInt1 = 16
-        cudaResViewFormatSignedInt2 = 17
-        cudaResViewFormatSignedInt4 = 18
-        cudaResViewFormatHalf1 = 19
-        cudaResViewFormatHalf2 = 20
-        cudaResViewFormatHalf4 = 21
-        cudaResViewFormatFloat1 = 22
-        cudaResViewFormatFloat2 = 23
-        cudaResViewFormatFloat4 = 24
-        cudaResViewFormatUnsignedBlockCompressed1 = 25
-        cudaResViewFormatUnsignedBlockCompressed2 = 26
-        cudaResViewFormatUnsignedBlockCompressed3 = 27
-        cudaResViewFormatUnsignedBlockCompressed4 = 28
-        cudaResViewFormatSignedBlockCompressed4 = 29
-        cudaResViewFormatUnsignedBlockCompressed5 = 30
-        cudaResViewFormatSignedBlockCompressed5 = 31
-        cudaResViewFormatUnsignedBlockCompressed6H = 32
-        cudaResViewFormatSignedBlockCompressed6H = 33
-        cudaResViewFormatUnsignedBlockCompressed7 = 34
-
-    cdef struct _cudaResourceDesc_res_res_array_s:
+    cdef struct anon_struct1:
         cudaArray_t array
 
-    cdef struct _cudaResourceDesc_res_res_mipmap_s:
+    cdef struct anon_struct2:
         cudaMipmappedArray_t mipmap
 
-    cdef struct _cudaResourceDesc_res_res_linear_s:
+    cdef struct anon_struct3:
         void* devPtr
         cudaChannelFormatDesc desc
         size_t sizeInBytes
 
-    cdef struct _cudaResourceDesc_res_res_pitch2D_s:
+    cdef struct anon_struct4:
         void* devPtr
         cudaChannelFormatDesc desc
         size_t width
         size_t height
         size_t pitchInBytes
 
-    cdef union _cudaResourceDesc_res_u:
-        _cudaResourceDesc_res_res_array_s array
-        _cudaResourceDesc_res_res_mipmap_s mipmap
-        _cudaResourceDesc_res_res_linear_s linear
-        _cudaResourceDesc_res_res_pitch2D_s pitch2D
+    cdef union anon_union0:
+        anon_struct1 array
+        anon_struct2 mipmap
+        anon_struct3 linear
+        anon_struct4 pitch2D
 
     cdef struct cudaResourceDesc:
         cudaResourceType resType
-        _cudaResourceDesc_res_u res
+        anon_union0 res
 
     cdef struct cudaResourceViewDesc:
         cudaResourceViewFormat format
@@ -442,273 +306,37 @@ cdef extern from "driver_types.h":
         int maxDynamicSharedSizeBytes
         int preferredShmemCarveout
 
-    cdef enum cudaFuncAttribute:
-        cudaFuncAttributeMaxDynamicSharedMemorySize = 8
-        cudaFuncAttributePreferredSharedMemoryCarveout = 9
-        cudaFuncAttributeClusterDimMustBeSet = 10
-        cudaFuncAttributeRequiredClusterWidth = 11
-        cudaFuncAttributeRequiredClusterHeight = 12
-        cudaFuncAttributeRequiredClusterDepth = 13
-        cudaFuncAttributeNonPortableClusterSizeAllowed = 14
-        cudaFuncAttributeClusterSchedulingPolicyPreference = 15
-        cudaFuncAttributeMax = 16
-
-    cdef enum cudaFuncCache:
-        cudaFuncCachePreferNone = 0
-        cudaFuncCachePreferShared = 1
-        cudaFuncCachePreferL1 = 2
-        cudaFuncCachePreferEqual = 3
-
-    cdef enum cudaSharedMemConfig:
-        cudaSharedMemBankSizeDefault = 0
-        cudaSharedMemBankSizeFourByte = 1
-        cudaSharedMemBankSizeEightByte = 2
-
-    cdef enum cudaSharedCarveout:
-        cudaSharedmemCarveoutDefault = -1
-        cudaSharedmemCarveoutMaxShared = 100
-        cudaSharedmemCarveoutMaxL1 = 0
-
-    cdef enum cudaComputeMode:
-        cudaComputeModeDefault = 0
-        cudaComputeModeExclusive = 1
-        cudaComputeModeProhibited = 2
-        cudaComputeModeExclusiveProcess = 3
-
-    cdef enum cudaLimit:
-        cudaLimitStackSize = 0
-        cudaLimitPrintfFifoSize = 1
-        cudaLimitMallocHeapSize = 2
-        cudaLimitDevRuntimeSyncDepth = 3
-        cudaLimitDevRuntimePendingLaunchCount = 4
-        cudaLimitMaxL2FetchGranularity = 5
-        cudaLimitPersistingL2CacheSize = 6
+    cdef struct cudaMemLocation:
+        cudaMemLocationType type
+        int id
 
-    cdef enum cudaMemoryAdvise:
-        cudaMemAdviseSetReadMostly = 1
-        cudaMemAdviseUnsetReadMostly = 2
-        cudaMemAdviseSetPreferredLocation = 3
-        cudaMemAdviseUnsetPreferredLocation = 4
-        cudaMemAdviseSetAccessedBy = 5
-        cudaMemAdviseUnsetAccessedBy = 6
+    cdef struct cudaMemAccessDesc:
+        cudaMemLocation location
+        cudaMemAccessFlags flags
 
-    cdef enum cudaMemRangeAttribute:
-        cudaMemRangeAttributeReadMostly = 1
-        cudaMemRangeAttributePreferredLocation = 2
-        cudaMemRangeAttributeAccessedBy = 3
-        cudaMemRangeAttributeLastPrefetchLocation = 4
+    cdef struct cudaMemPoolProps:
+        cudaMemAllocationType allocType
+        cudaMemAllocationHandleType handleTypes
+        cudaMemLocation location
+        void* win32SecurityAttributes
+        unsigned char reserved[64]
 
-    cdef enum cudaOutputMode:
-        cudaKeyValuePair = 0
-        cudaCSV = 1
+    cdef struct cudaMemPoolPtrExportData:
+        unsigned char reserved[64]
 
-    cdef enum cudaFlushGPUDirectRDMAWritesOptions:
-        cudaFlushGPUDirectRDMAWritesOptionHost = 1
-        cudaFlushGPUDirectRDMAWritesOptionMemOps = 2
+    cdef struct cudaMemAllocNodeParams:
+        cudaMemPoolProps poolProps
+        const cudaMemAccessDesc* accessDescs
+        size_t accessDescCount
+        size_t bytesize
+        void* dptr
 
-    cdef enum cudaGPUDirectRDMAWritesOrdering:
-        cudaGPUDirectRDMAWritesOrderingNone = 0
-        cudaGPUDirectRDMAWritesOrderingOwner = 100
-        cudaGPUDirectRDMAWritesOrderingAllDevices = 200
+    cdef struct CUuuid_st:
+        char bytes[16]
 
-    cdef enum cudaFlushGPUDirectRDMAWritesScope:
-        cudaFlushGPUDirectRDMAWritesToOwner = 100
-        cudaFlushGPUDirectRDMAWritesToAllDevices = 200
+    ctypedef CUuuid_st CUuuid
 
-    cdef enum cudaFlushGPUDirectRDMAWritesTarget:
-        cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = 0
-
-    cdef enum cudaDeviceAttr:
-        cudaDevAttrMaxThreadsPerBlock = 1
-        cudaDevAttrMaxBlockDimX = 2
-        cudaDevAttrMaxBlockDimY = 3
-        cudaDevAttrMaxBlockDimZ = 4
-        cudaDevAttrMaxGridDimX = 5
-        cudaDevAttrMaxGridDimY = 6
-        cudaDevAttrMaxGridDimZ = 7
-        cudaDevAttrMaxSharedMemoryPerBlock = 8
-        cudaDevAttrTotalConstantMemory = 9
-        cudaDevAttrWarpSize = 10
-        cudaDevAttrMaxPitch = 11
-        cudaDevAttrMaxRegistersPerBlock = 12
-        cudaDevAttrClockRate = 13
-        cudaDevAttrTextureAlignment = 14
-        cudaDevAttrGpuOverlap = 15
-        cudaDevAttrMultiProcessorCount = 16
-        cudaDevAttrKernelExecTimeout = 17
-        cudaDevAttrIntegrated = 18
-        cudaDevAttrCanMapHostMemory = 19
-        cudaDevAttrComputeMode = 20
-        cudaDevAttrMaxTexture1DWidth = 21
-        cudaDevAttrMaxTexture2DWidth = 22
-        cudaDevAttrMaxTexture2DHeight = 23
-        cudaDevAttrMaxTexture3DWidth = 24
-        cudaDevAttrMaxTexture3DHeight = 25
-        cudaDevAttrMaxTexture3DDepth = 26
-        cudaDevAttrMaxTexture2DLayeredWidth = 27
-        cudaDevAttrMaxTexture2DLayeredHeight = 28
-        cudaDevAttrMaxTexture2DLayeredLayers = 29
-        cudaDevAttrSurfaceAlignment = 30
-        cudaDevAttrConcurrentKernels = 31
-        cudaDevAttrEccEnabled = 32
-        cudaDevAttrPciBusId = 33
-        cudaDevAttrPciDeviceId = 34
-        cudaDevAttrTccDriver = 35
-        cudaDevAttrMemoryClockRate = 36
-        cudaDevAttrGlobalMemoryBusWidth = 37
-        cudaDevAttrL2CacheSize = 38
-        cudaDevAttrMaxThreadsPerMultiProcessor = 39
-        cudaDevAttrAsyncEngineCount = 40
-        cudaDevAttrUnifiedAddressing = 41
-        cudaDevAttrMaxTexture1DLayeredWidth = 42
-        cudaDevAttrMaxTexture1DLayeredLayers = 43
-        cudaDevAttrMaxTexture2DGatherWidth = 45
-        cudaDevAttrMaxTexture2DGatherHeight = 46
-        cudaDevAttrMaxTexture3DWidthAlt = 47
-        cudaDevAttrMaxTexture3DHeightAlt = 48
-        cudaDevAttrMaxTexture3DDepthAlt = 49
-        cudaDevAttrPciDomainId = 50
-        cudaDevAttrTexturePitchAlignment = 51
-        cudaDevAttrMaxTextureCubemapWidth = 52
-        cudaDevAttrMaxTextureCubemapLayeredWidth = 53
-        cudaDevAttrMaxTextureCubemapLayeredLayers = 54
-        cudaDevAttrMaxSurface1DWidth = 55
-        cudaDevAttrMaxSurface2DWidth = 56
-        cudaDevAttrMaxSurface2DHeight = 57
-        cudaDevAttrMaxSurface3DWidth = 58
-        cudaDevAttrMaxSurface3DHeight = 59
-        cudaDevAttrMaxSurface3DDepth = 60
-        cudaDevAttrMaxSurface1DLayeredWidth = 61
-        cudaDevAttrMaxSurface1DLayeredLayers = 62
-        cudaDevAttrMaxSurface2DLayeredWidth = 63
-        cudaDevAttrMaxSurface2DLayeredHeight = 64
-        cudaDevAttrMaxSurface2DLayeredLayers = 65
-        cudaDevAttrMaxSurfaceCubemapWidth = 66
-        cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67
-        cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68
-        cudaDevAttrMaxTexture1DLinearWidth = 69
-        cudaDevAttrMaxTexture2DLinearWidth = 70
-        cudaDevAttrMaxTexture2DLinearHeight = 71
-        cudaDevAttrMaxTexture2DLinearPitch = 72
-        cudaDevAttrMaxTexture2DMipmappedWidth = 73
-        cudaDevAttrMaxTexture2DMipmappedHeight = 74
-        cudaDevAttrComputeCapabilityMajor = 75
-        cudaDevAttrComputeCapabilityMinor = 76
-        cudaDevAttrMaxTexture1DMipmappedWidth = 77
-        cudaDevAttrStreamPrioritiesSupported = 78
-        cudaDevAttrGlobalL1CacheSupported = 79
-        cudaDevAttrLocalL1CacheSupported = 80
-        cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81
-        cudaDevAttrMaxRegistersPerMultiprocessor = 82
-        cudaDevAttrManagedMemory = 83
-        cudaDevAttrIsMultiGpuBoard = 84
-        cudaDevAttrMultiGpuBoardGroupID = 85
-        cudaDevAttrHostNativeAtomicSupported = 86
-        cudaDevAttrSingleToDoublePrecisionPerfRatio = 87
-        cudaDevAttrPageableMemoryAccess = 88
-        cudaDevAttrConcurrentManagedAccess = 89
-        cudaDevAttrComputePreemptionSupported = 90
-        cudaDevAttrCanUseHostPointerForRegisteredMem = 91
-        cudaDevAttrReserved92 = 92
-        cudaDevAttrReserved93 = 93
-        cudaDevAttrReserved94 = 94
-        cudaDevAttrCooperativeLaunch = 95
-        cudaDevAttrCooperativeMultiDeviceLaunch = 96
-        cudaDevAttrMaxSharedMemoryPerBlockOptin = 97
-        cudaDevAttrCanFlushRemoteWrites = 98
-        cudaDevAttrHostRegisterSupported = 99
-        cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100
-        cudaDevAttrDirectManagedMemAccessFromHost = 101
-        cudaDevAttrMaxBlocksPerMultiprocessor = 106
-        cudaDevAttrMaxPersistingL2CacheSize = 108
-        cudaDevAttrMaxAccessPolicyWindowSize = 109
-        cudaDevAttrReservedSharedMemoryPerBlock = 111
-        cudaDevAttrSparseCudaArraySupported = 112
-        cudaDevAttrHostRegisterReadOnlySupported = 113
-        cudaDevAttrTimelineSemaphoreInteropSupported = 114
-        cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114
-        cudaDevAttrMemoryPoolsSupported = 115
-        cudaDevAttrGPUDirectRDMASupported = 116
-        cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117
-        cudaDevAttrGPUDirectRDMAWritesOrdering = 118
-        cudaDevAttrMemoryPoolSupportedHandleTypes = 119
-        cudaDevAttrClusterLaunch = 120
-        cudaDevAttrDeferredMappingCudaArraySupported = 121
-        cudaDevAttrMax = 122
-
-    cdef enum cudaMemPoolAttr:
-        cudaMemPoolReuseFollowEventDependencies = 1
-        cudaMemPoolReuseAllowOpportunistic = 2
-        cudaMemPoolReuseAllowInternalDependencies = 3
-        cudaMemPoolAttrReleaseThreshold = 4
-        cudaMemPoolAttrReservedMemCurrent = 5
-        cudaMemPoolAttrReservedMemHigh = 6
-        cudaMemPoolAttrUsedMemCurrent = 7
-        cudaMemPoolAttrUsedMemHigh = 8
-
-    cdef enum cudaMemLocationType:
-        cudaMemLocationTypeInvalid = 0
-        cudaMemLocationTypeDevice = 1
-
-    cdef struct cudaMemLocation:
-        cudaMemLocationType type
-        int id
-
-    cdef enum cudaMemAccessFlags:
-        cudaMemAccessFlagsProtNone = 0
-        cudaMemAccessFlagsProtRead = 1
-        cudaMemAccessFlagsProtReadWrite = 3
-
-    cdef struct cudaMemAccessDesc:
-        cudaMemLocation location
-        cudaMemAccessFlags flags
-
-    cdef enum cudaMemAllocationType:
-        cudaMemAllocationTypeInvalid = 0
-        cudaMemAllocationTypePinned = 1
-        cudaMemAllocationTypeMax = 2147483647
-
-    cdef enum cudaMemAllocationHandleType:
-        cudaMemHandleTypeNone = 0
-        cudaMemHandleTypePosixFileDescriptor = 1
-        cudaMemHandleTypeWin32 = 2
-        cudaMemHandleTypeWin32Kmt = 4
-
-    cdef struct cudaMemPoolProps:
-        cudaMemAllocationType allocType
-        cudaMemAllocationHandleType handleTypes
-        cudaMemLocation location
-        void* win32SecurityAttributes
-        unsigned char reserved[64]
-
-    cdef struct cudaMemPoolPtrExportData:
-        unsigned char reserved[64]
-
-    cdef struct cudaMemAllocNodeParams:
-        cudaMemPoolProps poolProps
-        const cudaMemAccessDesc* accessDescs
-        size_t accessDescCount
-        size_t bytesize
-        void* dptr
-
-    cdef enum cudaGraphMemAttributeType:
-        cudaGraphMemAttrUsedMemCurrent = 0
-        cudaGraphMemAttrUsedMemHigh = 1
-        cudaGraphMemAttrReservedMemCurrent = 2
-        cudaGraphMemAttrReservedMemHigh = 3
-
-    cdef enum cudaDeviceP2PAttr:
-        cudaDevP2PAttrPerformanceRank = 1
-        cudaDevP2PAttrAccessSupported = 2
-        cudaDevP2PAttrNativeAtomicSupported = 3
-        cudaDevP2PAttrCudaArrayAccessSupported = 4
-
-    cdef struct CUuuid_st:
-        char bytes[16]
-
-    ctypedef CUuuid_st CUuuid
-
-    ctypedef CUuuid_st cudaUUID_t
+    ctypedef CUuuid_st cudaUUID_t
 
     cdef struct cudaDeviceProp:
         char name[256]
@@ -802,28 +430,18 @@ cdef extern from "driver_types.h":
 
     ctypedef cudaIpcMemHandle_st cudaIpcMemHandle_t
 
-    cdef enum cudaExternalMemoryHandleType:
-        cudaExternalMemoryHandleTypeOpaqueFd = 1
-        cudaExternalMemoryHandleTypeOpaqueWin32 = 2
-        cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3
-        cudaExternalMemoryHandleTypeD3D12Heap = 4
-        cudaExternalMemoryHandleTypeD3D12Resource = 5
-        cudaExternalMemoryHandleTypeD3D11Resource = 6
-        cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7
-        cudaExternalMemoryHandleTypeNvSciBuf = 8
-
-    cdef struct _cudaExternalMemoryHandleDesc_handle_handle_win32_s:
+    cdef struct anon_struct5:
         void* handle
         const void* name
 
-    cdef union _cudaExternalMemoryHandleDesc_handle_u:
+    cdef union anon_union1:
         int fd
-        _cudaExternalMemoryHandleDesc_handle_handle_win32_s win32
+        anon_struct5 win32
         const void* nvSciBufObject
 
     cdef struct cudaExternalMemoryHandleDesc:
         cudaExternalMemoryHandleType type
-        _cudaExternalMemoryHandleDesc_handle_u handle
+        anon_union1 handle
         unsigned long long size
         unsigned int flags
 
@@ -839,77 +457,63 @@ cdef extern from "driver_types.h":
         unsigned int flags
         unsigned int numLevels
 
-    cdef enum cudaExternalSemaphoreHandleType:
-        cudaExternalSemaphoreHandleTypeOpaqueFd = 1
-        cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2
-        cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3
-        cudaExternalSemaphoreHandleTypeD3D12Fence = 4
-        cudaExternalSemaphoreHandleTypeD3D11Fence = 5
-        cudaExternalSemaphoreHandleTypeNvSciSync = 6
-        cudaExternalSemaphoreHandleTypeKeyedMutex = 7
-        cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8
-        cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9
-        cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10
-
-    cdef struct _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s:
+    cdef struct anon_struct6:
         void* handle
         const void* name
 
-    cdef union _cudaExternalSemaphoreHandleDesc_handle_u:
+    cdef union anon_union2:
         int fd
-        _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s win32
+        anon_struct6 win32
         const void* nvSciSyncObj
 
     cdef struct cudaExternalSemaphoreHandleDesc:
         cudaExternalSemaphoreHandleType type
-        _cudaExternalSemaphoreHandleDesc_handle_u handle
+        anon_union2 handle
         unsigned int flags
 
-    cdef struct _cudaExternalSemaphoreSignalParams_params_params_fence_s:
+    cdef struct anon_struct13:
         unsigned long long value
 
-    cdef union _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u:
+    cdef union anon_union5:
         void* fence
         unsigned long long reserved
 
-    cdef struct _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s:
+    cdef struct anon_struct14:
         unsigned long long key
 
-    cdef struct _cudaExternalSemaphoreSignalParams_params_s:
-        _cudaExternalSemaphoreSignalParams_params_params_fence_s fence
-        _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u nvSciSync
-        _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s keyedMutex
+    cdef struct anon_struct15:
+        anon_struct13 fence
+        anon_union5 nvSciSync
+        anon_struct14 keyedMutex
         unsigned int reserved[12]
 
     cdef struct cudaExternalSemaphoreSignalParams:
-        _cudaExternalSemaphoreSignalParams_params_s params
+        anon_struct15 params
         unsigned int flags
         unsigned int reserved[16]
 
-    cdef struct _cudaExternalSemaphoreWaitParams_params_params_fence_s:
+    cdef struct anon_struct16:
         unsigned long long value
 
-    cdef union _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u:
+    cdef union anon_union6:
         void* fence
         unsigned long long reserved
 
-    cdef struct _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s:
+    cdef struct anon_struct17:
         unsigned long long key
         unsigned int timeoutMs
 
-    cdef struct _cudaExternalSemaphoreWaitParams_params_s:
-        _cudaExternalSemaphoreWaitParams_params_params_fence_s fence
-        _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u nvSciSync
-        _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s keyedMutex
+    cdef struct anon_struct18:
+        anon_struct16 fence
+        anon_union6 nvSciSync
+        anon_struct17 keyedMutex
         unsigned int reserved[10]
 
     cdef struct cudaExternalSemaphoreWaitParams:
-        _cudaExternalSemaphoreWaitParams_params_s params
+        anon_struct18 params
         unsigned int flags
         unsigned int reserved[16]
 
-    ctypedef cudaError cudaError_t
-
     cdef struct CUstream_st:
         pass
     ctypedef CUstream_st* cudaStream_t
@@ -922,8 +526,6 @@ cdef extern from "driver_types.h":
         pass
     ctypedef cudaGraphicsResource* cudaGraphicsResource_t
 
-    ctypedef cudaOutputMode cudaOutputMode_t
-
     cdef struct CUexternalMemory_st:
         pass
     ctypedef CUexternalMemory_st* cudaExternalMemory_t
@@ -952,11 +554,6 @@ cdef extern from "driver_types.h":
         pass
     ctypedef CUmemPoolHandle_st* cudaMemPool_t
 
-    cdef enum cudaCGScope:
-        cudaCGScopeInvalid = 0
-        cudaCGScopeGrid = 1
-        cudaCGScopeMultiGrid = 2
-
     cdef struct cudaKernelNodeParams:
         void* func
         dim3 gridDim
@@ -975,74 +572,27 @@ cdef extern from "driver_types.h":
         const cudaExternalSemaphoreWaitParams* paramsArray
         unsigned int numExtSems
 
-    cdef enum cudaGraphNodeType:
-        cudaGraphNodeTypeKernel = 0
-        cudaGraphNodeTypeMemcpy = 1
-        cudaGraphNodeTypeMemset = 2
-        cudaGraphNodeTypeHost = 3
-        cudaGraphNodeTypeGraph = 4
-        cudaGraphNodeTypeEmpty = 5
-        cudaGraphNodeTypeWaitEvent = 6
-        cudaGraphNodeTypeEventRecord = 7
-        cudaGraphNodeTypeExtSemaphoreSignal = 8
-        cudaGraphNodeTypeExtSemaphoreWait = 9
-        cudaGraphNodeTypeMemAlloc = 10
-        cudaGraphNodeTypeMemFree = 11
-        cudaGraphNodeTypeCount = 12
-
     cdef struct CUgraphExec_st:
         pass
     ctypedef CUgraphExec_st* cudaGraphExec_t
 
-    cdef enum cudaGraphExecUpdateResult:
-        cudaGraphExecUpdateSuccess = 0
-        cudaGraphExecUpdateError = 1
-        cudaGraphExecUpdateErrorTopologyChanged = 2
-        cudaGraphExecUpdateErrorNodeTypeChanged = 3
-        cudaGraphExecUpdateErrorFunctionChanged = 4
-        cudaGraphExecUpdateErrorParametersChanged = 5
-        cudaGraphExecUpdateErrorNotSupported = 6
-        cudaGraphExecUpdateErrorUnsupportedFunctionChange = 7
-        cudaGraphExecUpdateErrorAttributesChanged = 8
+    cdef enum cudaLaunchAttributeID:
+        cudaLaunchAttributeIgnore = 0
+        cudaLaunchAttributeAccessPolicyWindow = 1
+        cudaLaunchAttributeCooperative = 2
+        cudaLaunchAttributeSynchronizationPolicy = 3
+        cudaLaunchAttributeClusterDimension = 4
+        cudaLaunchAttributeClusterSchedulingPolicyPreference = 5
+        cudaLaunchAttributeProgrammaticStreamSerialization = 6
+        cudaLaunchAttributeProgrammaticEvent = 7
+        cudaLaunchAttributePriority = 8
 
-    cdef enum cudaGetDriverEntryPointFlags:
-        cudaEnableDefault = 0
-        cudaEnableLegacyStream = 1
-        cudaEnablePerThreadDefaultStream = 2
+    cdef struct anon_struct19:
+        unsigned int x
+        unsigned int y
+        unsigned int z
 
-    cdef enum cudaGraphDebugDotFlags:
-        cudaGraphDebugDotFlagsVerbose = 1
-        cudaGraphDebugDotFlagsKernelNodeParams = 4
-        cudaGraphDebugDotFlagsMemcpyNodeParams = 8
-        cudaGraphDebugDotFlagsMemsetNodeParams = 16
-        cudaGraphDebugDotFlagsHostNodeParams = 32
-        cudaGraphDebugDotFlagsEventNodeParams = 64
-        cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 128
-        cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 256
-        cudaGraphDebugDotFlagsKernelNodeAttributes = 512
-        cudaGraphDebugDotFlagsHandles = 1024
-
-    cdef enum cudaGraphInstantiateFlags:
-        cudaGraphInstantiateFlagAutoFreeOnLaunch = 1
-        cudaGraphInstantiateFlagUseNodePriority = 8
-
-    cdef enum cudaLaunchAttributeID:
-        cudaLaunchAttributeIgnore = 0
-        cudaLaunchAttributeAccessPolicyWindow = 1
-        cudaLaunchAttributeCooperative = 2
-        cudaLaunchAttributeSynchronizationPolicy = 3
-        cudaLaunchAttributeClusterDimension = 4
-        cudaLaunchAttributeClusterSchedulingPolicyPreference = 5
-        cudaLaunchAttributeProgrammaticStreamSerialization = 6
-        cudaLaunchAttributeProgrammaticEvent = 7
-        cudaLaunchAttributePriority = 8
-
-    cdef struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s:
-        unsigned int x
-        unsigned int y
-        unsigned int z
-
-    cdef struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s:
+    cdef struct anon_struct20:
         cudaEvent_t event
         int flags
         int triggerAtBlockStart
@@ -1052,10 +602,10 @@ cdef extern from "driver_types.h":
         cudaAccessPolicyWindow accessPolicyWindow
         int cooperative
         cudaSynchronizationPolicy syncPolicy
-        _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s clusterDim
+        anon_struct19 clusterDim
         cudaClusterSchedulingPolicy clusterSchedulingPolicyPreference
         int programmaticStreamSerializationAllowed
-        _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s programmaticEvent
+        anon_struct20 programmaticEvent
         int priority
 
     cdef struct cudaLaunchAttribute_st:
@@ -1064,104 +614,460 @@ cdef extern from "driver_types.h":
 
     ctypedef cudaLaunchAttribute_st cudaLaunchAttribute
 
+    cdef enum cudaChannelFormatKind:
+        cudaChannelFormatKindSigned = 0
+        cudaChannelFormatKindUnsigned = 1
+        cudaChannelFormatKindFloat = 2
+        cudaChannelFormatKindNone = 3
+        cudaChannelFormatKindNV12 = 4
+        cudaChannelFormatKindUnsignedNormalized8X1 = 5
+        cudaChannelFormatKindUnsignedNormalized8X2 = 6
+        cudaChannelFormatKindUnsignedNormalized8X4 = 7
+        cudaChannelFormatKindUnsignedNormalized16X1 = 8
+        cudaChannelFormatKindUnsignedNormalized16X2 = 9
+        cudaChannelFormatKindUnsignedNormalized16X4 = 10
+        cudaChannelFormatKindSignedNormalized8X1 = 11
+        cudaChannelFormatKindSignedNormalized8X2 = 12
+        cudaChannelFormatKindSignedNormalized8X4 = 13
+        cudaChannelFormatKindSignedNormalized16X1 = 14
+        cudaChannelFormatKindSignedNormalized16X2 = 15
+        cudaChannelFormatKindSignedNormalized16X4 = 16
+        cudaChannelFormatKindUnsignedBlockCompressed1 = 17
+        cudaChannelFormatKindUnsignedBlockCompressed1SRGB = 18
+        cudaChannelFormatKindUnsignedBlockCompressed2 = 19
+        cudaChannelFormatKindUnsignedBlockCompressed2SRGB = 20
+        cudaChannelFormatKindUnsignedBlockCompressed3 = 21
+        cudaChannelFormatKindUnsignedBlockCompressed3SRGB = 22
+        cudaChannelFormatKindUnsignedBlockCompressed4 = 23
+        cudaChannelFormatKindSignedBlockCompressed4 = 24
+        cudaChannelFormatKindUnsignedBlockCompressed5 = 25
+        cudaChannelFormatKindSignedBlockCompressed5 = 26
+        cudaChannelFormatKindUnsignedBlockCompressed6H = 27
+        cudaChannelFormatKindSignedBlockCompressed6H = 28
+        cudaChannelFormatKindUnsignedBlockCompressed7 = 29
+        cudaChannelFormatKindUnsignedBlockCompressed7SRGB = 30
 
-cdef enum cudaStreamAttrID:
-    cudaStreamAttributeAccessPolicyWindow = 1
-    cudaStreamAttributeSynchronizationPolicy = 3
+    cdef enum cudaMemoryType:
+        cudaMemoryTypeUnregistered = 0
+        cudaMemoryTypeHost = 1
+        cudaMemoryTypeDevice = 2
+        cudaMemoryTypeManaged = 3
 
-cdef enum cudaKernelNodeAttrID:
-    cudaKernelNodeAttributeAccessPolicyWindow = 1
-    cudaKernelNodeAttributeCooperative = 2
-    cudaKernelNodeAttributePriority = 8
+    cdef enum cudaMemcpyKind:
+        cudaMemcpyHostToHost = 0
+        cudaMemcpyHostToDevice = 1
+        cudaMemcpyDeviceToHost = 2
+        cudaMemcpyDeviceToDevice = 3
+        cudaMemcpyDefault = 4
 
-ctypedef cudaLaunchAttributeValue cudaStreamAttrValue
+    cdef enum cudaAccessProperty:
+        cudaAccessPropertyNormal = 0
+        cudaAccessPropertyStreaming = 1
+        cudaAccessPropertyPersisting = 2
 
-ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue
+    cdef enum cudaStreamCaptureStatus:
+        cudaStreamCaptureStatusNone = 0
+        cudaStreamCaptureStatusActive = 1
+        cudaStreamCaptureStatusInvalidated = 2
 
-from libc.stdint cimport uint32_t
+    cdef enum cudaStreamCaptureMode:
+        cudaStreamCaptureModeGlobal = 0
+        cudaStreamCaptureModeThreadLocal = 1
+        cudaStreamCaptureModeRelaxed = 2
 
+    cdef enum cudaSynchronizationPolicy:
+        cudaSyncPolicyAuto = 1
+        cudaSyncPolicySpin = 2
+        cudaSyncPolicyYield = 3
+        cudaSyncPolicyBlockingSync = 4
 
-ctypedef unsigned int GLenum
+    cdef enum cudaClusterSchedulingPolicy:
+        cudaClusterSchedulingPolicyDefault = 0
+        cudaClusterSchedulingPolicySpread = 1
+        cudaClusterSchedulingPolicyLoadBalancing = 2
 
-ctypedef unsigned int GLuint
+    cdef enum cudaStreamUpdateCaptureDependenciesFlags:
+        cudaStreamAddCaptureDependencies = 0
+        cudaStreamSetCaptureDependencies = 1
 
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLImageKHR
+    cdef enum cudaUserObjectFlags:
+        cudaUserObjectNoDestructorSync = 1
 
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLStreamKHR
+    cdef enum cudaUserObjectRetainFlags:
+        cudaGraphUserObjectMove = 1
 
-ctypedef unsigned int EGLint
+    cdef enum cudaGraphicsRegisterFlags:
+        cudaGraphicsRegisterFlagsNone = 0
+        cudaGraphicsRegisterFlagsReadOnly = 1
+        cudaGraphicsRegisterFlagsWriteDiscard = 2
+        cudaGraphicsRegisterFlagsSurfaceLoadStore = 4
+        cudaGraphicsRegisterFlagsTextureGather = 8
 
-cdef extern from "":
-    cdef struct void:
-        pass
-ctypedef void* EGLSyncKHR
+    cdef enum cudaGraphicsMapFlags:
+        cudaGraphicsMapFlagsNone = 0
+        cudaGraphicsMapFlagsReadOnly = 1
+        cudaGraphicsMapFlagsWriteDiscard = 2
 
-ctypedef uint32_t VdpDevice
+    cdef enum cudaGraphicsCubeFace:
+        cudaGraphicsCubeFacePositiveX = 0
+        cudaGraphicsCubeFaceNegativeX = 1
+        cudaGraphicsCubeFacePositiveY = 2
+        cudaGraphicsCubeFaceNegativeY = 3
+        cudaGraphicsCubeFacePositiveZ = 4
+        cudaGraphicsCubeFaceNegativeZ = 5
 
-ctypedef unsigned long long VdpGetProcAddress
+    cdef enum cudaResourceType:
+        cudaResourceTypeArray = 0
+        cudaResourceTypeMipmappedArray = 1
+        cudaResourceTypeLinear = 2
+        cudaResourceTypePitch2D = 3
 
-ctypedef uint32_t VdpVideoSurface
+    cdef enum cudaResourceViewFormat:
+        cudaResViewFormatNone = 0
+        cudaResViewFormatUnsignedChar1 = 1
+        cudaResViewFormatUnsignedChar2 = 2
+        cudaResViewFormatUnsignedChar4 = 3
+        cudaResViewFormatSignedChar1 = 4
+        cudaResViewFormatSignedChar2 = 5
+        cudaResViewFormatSignedChar4 = 6
+        cudaResViewFormatUnsignedShort1 = 7
+        cudaResViewFormatUnsignedShort2 = 8
+        cudaResViewFormatUnsignedShort4 = 9
+        cudaResViewFormatSignedShort1 = 10
+        cudaResViewFormatSignedShort2 = 11
+        cudaResViewFormatSignedShort4 = 12
+        cudaResViewFormatUnsignedInt1 = 13
+        cudaResViewFormatUnsignedInt2 = 14
+        cudaResViewFormatUnsignedInt4 = 15
+        cudaResViewFormatSignedInt1 = 16
+        cudaResViewFormatSignedInt2 = 17
+        cudaResViewFormatSignedInt4 = 18
+        cudaResViewFormatHalf1 = 19
+        cudaResViewFormatHalf2 = 20
+        cudaResViewFormatHalf4 = 21
+        cudaResViewFormatFloat1 = 22
+        cudaResViewFormatFloat2 = 23
+        cudaResViewFormatFloat4 = 24
+        cudaResViewFormatUnsignedBlockCompressed1 = 25
+        cudaResViewFormatUnsignedBlockCompressed2 = 26
+        cudaResViewFormatUnsignedBlockCompressed3 = 27
+        cudaResViewFormatUnsignedBlockCompressed4 = 28
+        cudaResViewFormatSignedBlockCompressed4 = 29
+        cudaResViewFormatUnsignedBlockCompressed5 = 30
+        cudaResViewFormatSignedBlockCompressed5 = 31
+        cudaResViewFormatUnsignedBlockCompressed6H = 32
+        cudaResViewFormatSignedBlockCompressed6H = 33
+        cudaResViewFormatUnsignedBlockCompressed7 = 34
 
-ctypedef uint32_t VdpOutputSurface
+    cdef enum cudaFuncAttribute:
+        cudaFuncAttributeMaxDynamicSharedMemorySize = 8
+        cudaFuncAttributePreferredSharedMemoryCarveout = 9
+        cudaFuncAttributeClusterDimMustBeSet = 10
+        cudaFuncAttributeRequiredClusterWidth = 11
+        cudaFuncAttributeRequiredClusterHeight = 12
+        cudaFuncAttributeRequiredClusterDepth = 13
+        cudaFuncAttributeNonPortableClusterSizeAllowed = 14
+        cudaFuncAttributeClusterSchedulingPolicyPreference = 15
+        cudaFuncAttributeMax = 16
 
-cdef enum cudaGLDeviceList:
-    cudaGLDeviceListAll = 1
-    cudaGLDeviceListCurrentFrame = 2
-    cudaGLDeviceListNextFrame = 3
+    cdef enum cudaFuncCache:
+        cudaFuncCachePreferNone = 0
+        cudaFuncCachePreferShared = 1
+        cudaFuncCachePreferL1 = 2
+        cudaFuncCachePreferEqual = 3
 
-cdef enum cudaGLMapFlags:
-    cudaGLMapFlagsNone = 0
-    cudaGLMapFlagsReadOnly = 1
-    cudaGLMapFlagsWriteDiscard = 2
+    cdef enum cudaSharedMemConfig:
+        cudaSharedMemBankSizeDefault = 0
+        cudaSharedMemBankSizeFourByte = 1
+        cudaSharedMemBankSizeEightByte = 2
 
-{{if True or 'cudaVDPAUGetDevice' in found_functions}}
+    cdef enum cudaSharedCarveout:
+        cudaSharedmemCarveoutDefault = -1
+        cudaSharedmemCarveoutMaxL1 = 0
+        cudaSharedmemCarveoutMaxShared = 100
 
-cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaComputeMode:
+        cudaComputeModeDefault = 0
+        cudaComputeModeExclusive = 1
+        cudaComputeModeProhibited = 2
+        cudaComputeModeExclusiveProcess = 3
 
-{{if True or 'cudaVDPAUSetVDPAUDevice' in found_functions}}
+    cdef enum cudaLimit:
+        cudaLimitStackSize = 0
+        cudaLimitPrintfFifoSize = 1
+        cudaLimitMallocHeapSize = 2
+        cudaLimitDevRuntimeSyncDepth = 3
+        cudaLimitDevRuntimePendingLaunchCount = 4
+        cudaLimitMaxL2FetchGranularity = 5
+        cudaLimitPersistingL2CacheSize = 6
 
-cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaMemoryAdvise:
+        cudaMemAdviseSetReadMostly = 1
+        cudaMemAdviseUnsetReadMostly = 2
+        cudaMemAdviseSetPreferredLocation = 3
+        cudaMemAdviseUnsetPreferredLocation = 4
+        cudaMemAdviseSetAccessedBy = 5
+        cudaMemAdviseUnsetAccessedBy = 6
 
-{{if True or 'cudaGraphicsVDPAURegisterVideoSurface' in found_functions}}
+    cdef enum cudaMemRangeAttribute:
+        cudaMemRangeAttributeReadMostly = 1
+        cudaMemRangeAttributePreferredLocation = 2
+        cudaMemRangeAttributeAccessedBy = 3
+        cudaMemRangeAttributeLastPrefetchLocation = 4
 
-cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaFlushGPUDirectRDMAWritesOptions:
+        cudaFlushGPUDirectRDMAWritesOptionHost = 1
+        cudaFlushGPUDirectRDMAWritesOptionMemOps = 2
 
-{{if True or 'cudaGraphicsVDPAURegisterOutputSurface' in found_functions}}
+    cdef enum cudaGPUDirectRDMAWritesOrdering:
+        cudaGPUDirectRDMAWritesOrderingNone = 0
+        cudaGPUDirectRDMAWritesOrderingOwner = 100
+        cudaGPUDirectRDMAWritesOrderingAllDevices = 200
 
-cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaFlushGPUDirectRDMAWritesScope:
+        cudaFlushGPUDirectRDMAWritesToOwner = 100
+        cudaFlushGPUDirectRDMAWritesToAllDevices = 200
 
-{{if True or 'cudaGLGetDevices' in found_functions}}
+    cdef enum cudaFlushGPUDirectRDMAWritesTarget:
+        cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = 0
 
-cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaDeviceAttr:
+        cudaDevAttrMaxThreadsPerBlock = 1
+        cudaDevAttrMaxBlockDimX = 2
+        cudaDevAttrMaxBlockDimY = 3
+        cudaDevAttrMaxBlockDimZ = 4
+        cudaDevAttrMaxGridDimX = 5
+        cudaDevAttrMaxGridDimY = 6
+        cudaDevAttrMaxGridDimZ = 7
+        cudaDevAttrMaxSharedMemoryPerBlock = 8
+        cudaDevAttrTotalConstantMemory = 9
+        cudaDevAttrWarpSize = 10
+        cudaDevAttrMaxPitch = 11
+        cudaDevAttrMaxRegistersPerBlock = 12
+        cudaDevAttrClockRate = 13
+        cudaDevAttrTextureAlignment = 14
+        cudaDevAttrGpuOverlap = 15
+        cudaDevAttrMultiProcessorCount = 16
+        cudaDevAttrKernelExecTimeout = 17
+        cudaDevAttrIntegrated = 18
+        cudaDevAttrCanMapHostMemory = 19
+        cudaDevAttrComputeMode = 20
+        cudaDevAttrMaxTexture1DWidth = 21
+        cudaDevAttrMaxTexture2DWidth = 22
+        cudaDevAttrMaxTexture2DHeight = 23
+        cudaDevAttrMaxTexture3DWidth = 24
+        cudaDevAttrMaxTexture3DHeight = 25
+        cudaDevAttrMaxTexture3DDepth = 26
+        cudaDevAttrMaxTexture2DLayeredWidth = 27
+        cudaDevAttrMaxTexture2DLayeredHeight = 28
+        cudaDevAttrMaxTexture2DLayeredLayers = 29
+        cudaDevAttrSurfaceAlignment = 30
+        cudaDevAttrConcurrentKernels = 31
+        cudaDevAttrEccEnabled = 32
+        cudaDevAttrPciBusId = 33
+        cudaDevAttrPciDeviceId = 34
+        cudaDevAttrTccDriver = 35
+        cudaDevAttrMemoryClockRate = 36
+        cudaDevAttrGlobalMemoryBusWidth = 37
+        cudaDevAttrL2CacheSize = 38
+        cudaDevAttrMaxThreadsPerMultiProcessor = 39
+        cudaDevAttrAsyncEngineCount = 40
+        cudaDevAttrUnifiedAddressing = 41
+        cudaDevAttrMaxTexture1DLayeredWidth = 42
+        cudaDevAttrMaxTexture1DLayeredLayers = 43
+        cudaDevAttrMaxTexture2DGatherWidth = 45
+        cudaDevAttrMaxTexture2DGatherHeight = 46
+        cudaDevAttrMaxTexture3DWidthAlt = 47
+        cudaDevAttrMaxTexture3DHeightAlt = 48
+        cudaDevAttrMaxTexture3DDepthAlt = 49
+        cudaDevAttrPciDomainId = 50
+        cudaDevAttrTexturePitchAlignment = 51
+        cudaDevAttrMaxTextureCubemapWidth = 52
+        cudaDevAttrMaxTextureCubemapLayeredWidth = 53
+        cudaDevAttrMaxTextureCubemapLayeredLayers = 54
+        cudaDevAttrMaxSurface1DWidth = 55
+        cudaDevAttrMaxSurface2DWidth = 56
+        cudaDevAttrMaxSurface2DHeight = 57
+        cudaDevAttrMaxSurface3DWidth = 58
+        cudaDevAttrMaxSurface3DHeight = 59
+        cudaDevAttrMaxSurface3DDepth = 60
+        cudaDevAttrMaxSurface1DLayeredWidth = 61
+        cudaDevAttrMaxSurface1DLayeredLayers = 62
+        cudaDevAttrMaxSurface2DLayeredWidth = 63
+        cudaDevAttrMaxSurface2DLayeredHeight = 64
+        cudaDevAttrMaxSurface2DLayeredLayers = 65
+        cudaDevAttrMaxSurfaceCubemapWidth = 66
+        cudaDevAttrMaxSurfaceCubemapLayeredWidth = 67
+        cudaDevAttrMaxSurfaceCubemapLayeredLayers = 68
+        cudaDevAttrMaxTexture1DLinearWidth = 69
+        cudaDevAttrMaxTexture2DLinearWidth = 70
+        cudaDevAttrMaxTexture2DLinearHeight = 71
+        cudaDevAttrMaxTexture2DLinearPitch = 72
+        cudaDevAttrMaxTexture2DMipmappedWidth = 73
+        cudaDevAttrMaxTexture2DMipmappedHeight = 74
+        cudaDevAttrComputeCapabilityMajor = 75
+        cudaDevAttrComputeCapabilityMinor = 76
+        cudaDevAttrMaxTexture1DMipmappedWidth = 77
+        cudaDevAttrStreamPrioritiesSupported = 78
+        cudaDevAttrGlobalL1CacheSupported = 79
+        cudaDevAttrLocalL1CacheSupported = 80
+        cudaDevAttrMaxSharedMemoryPerMultiprocessor = 81
+        cudaDevAttrMaxRegistersPerMultiprocessor = 82
+        cudaDevAttrManagedMemory = 83
+        cudaDevAttrIsMultiGpuBoard = 84
+        cudaDevAttrMultiGpuBoardGroupID = 85
+        cudaDevAttrHostNativeAtomicSupported = 86
+        cudaDevAttrSingleToDoublePrecisionPerfRatio = 87
+        cudaDevAttrPageableMemoryAccess = 88
+        cudaDevAttrConcurrentManagedAccess = 89
+        cudaDevAttrComputePreemptionSupported = 90
+        cudaDevAttrCanUseHostPointerForRegisteredMem = 91
+        cudaDevAttrReserved92 = 92
+        cudaDevAttrReserved93 = 93
+        cudaDevAttrReserved94 = 94
+        cudaDevAttrCooperativeLaunch = 95
+        cudaDevAttrCooperativeMultiDeviceLaunch = 96
+        cudaDevAttrMaxSharedMemoryPerBlockOptin = 97
+        cudaDevAttrCanFlushRemoteWrites = 98
+        cudaDevAttrHostRegisterSupported = 99
+        cudaDevAttrPageableMemoryAccessUsesHostPageTables = 100
+        cudaDevAttrDirectManagedMemAccessFromHost = 101
+        cudaDevAttrMaxBlocksPerMultiprocessor = 106
+        cudaDevAttrMaxPersistingL2CacheSize = 108
+        cudaDevAttrMaxAccessPolicyWindowSize = 109
+        cudaDevAttrReservedSharedMemoryPerBlock = 111
+        cudaDevAttrSparseCudaArraySupported = 112
+        cudaDevAttrHostRegisterReadOnlySupported = 113
+        cudaDevAttrTimelineSemaphoreInteropSupported = 114
+        cudaDevAttrMaxTimelineSemaphoreInteropSupported = 114
+        cudaDevAttrMemoryPoolsSupported = 115
+        cudaDevAttrGPUDirectRDMASupported = 116
+        cudaDevAttrGPUDirectRDMAFlushWritesOptions = 117
+        cudaDevAttrGPUDirectRDMAWritesOrdering = 118
+        cudaDevAttrMemoryPoolSupportedHandleTypes = 119
+        cudaDevAttrClusterLaunch = 120
+        cudaDevAttrDeferredMappingCudaArraySupported = 121
+        cudaDevAttrMax = 122
 
-{{if True or 'cudaGraphicsGLRegisterImage' in found_functions}}
+    cdef enum cudaMemPoolAttr:
+        cudaMemPoolReuseFollowEventDependencies = 1
+        cudaMemPoolReuseAllowOpportunistic = 2
+        cudaMemPoolReuseAllowInternalDependencies = 3
+        cudaMemPoolAttrReleaseThreshold = 4
+        cudaMemPoolAttrReservedMemCurrent = 5
+        cudaMemPoolAttrReservedMemHigh = 6
+        cudaMemPoolAttrUsedMemCurrent = 7
+        cudaMemPoolAttrUsedMemHigh = 8
 
-cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaMemLocationType:
+        cudaMemLocationTypeInvalid = 0
+        cudaMemLocationTypeDevice = 1
 
-{{if True or 'cudaGraphicsGLRegisterBuffer' in found_functions}}
+    cdef enum cudaMemAccessFlags:
+        cudaMemAccessFlagsProtNone = 0
+        cudaMemAccessFlagsProtRead = 1
+        cudaMemAccessFlagsProtReadWrite = 3
 
-cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
+    cdef enum cudaMemAllocationType:
+        cudaMemAllocationTypeInvalid = 0
+        cudaMemAllocationTypePinned = 1
+        cudaMemAllocationTypeMax = 2147483647
+
+    cdef enum cudaMemAllocationHandleType:
+        cudaMemHandleTypeNone = 0
+        cudaMemHandleTypePosixFileDescriptor = 1
+        cudaMemHandleTypeWin32 = 2
+        cudaMemHandleTypeWin32Kmt = 4
+
+    cdef enum cudaGraphMemAttributeType:
+        cudaGraphMemAttrUsedMemCurrent = 0
+        cudaGraphMemAttrUsedMemHigh = 1
+        cudaGraphMemAttrReservedMemCurrent = 2
+        cudaGraphMemAttrReservedMemHigh = 3
+
+    cdef enum cudaDeviceP2PAttr:
+        cudaDevP2PAttrPerformanceRank = 1
+        cudaDevP2PAttrAccessSupported = 2
+        cudaDevP2PAttrNativeAtomicSupported = 3
+        cudaDevP2PAttrCudaArrayAccessSupported = 4
+
+    cdef enum cudaExternalMemoryHandleType:
+        cudaExternalMemoryHandleTypeOpaqueFd = 1
+        cudaExternalMemoryHandleTypeOpaqueWin32 = 2
+        cudaExternalMemoryHandleTypeOpaqueWin32Kmt = 3
+        cudaExternalMemoryHandleTypeD3D12Heap = 4
+        cudaExternalMemoryHandleTypeD3D12Resource = 5
+        cudaExternalMemoryHandleTypeD3D11Resource = 6
+        cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7
+        cudaExternalMemoryHandleTypeNvSciBuf = 8
+
+    cdef enum cudaExternalSemaphoreHandleType:
+        cudaExternalSemaphoreHandleTypeOpaqueFd = 1
+        cudaExternalSemaphoreHandleTypeOpaqueWin32 = 2
+        cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3
+        cudaExternalSemaphoreHandleTypeD3D12Fence = 4
+        cudaExternalSemaphoreHandleTypeD3D11Fence = 5
+        cudaExternalSemaphoreHandleTypeNvSciSync = 6
+        cudaExternalSemaphoreHandleTypeKeyedMutex = 7
+        cudaExternalSemaphoreHandleTypeKeyedMutexKmt = 8
+        cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = 9
+        cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = 10
+
+    cdef enum cudaCGScope:
+        cudaCGScopeInvalid = 0
+        cudaCGScopeGrid = 1
+        cudaCGScopeMultiGrid = 2
+
+    cdef enum cudaGraphNodeType:
+        cudaGraphNodeTypeKernel = 0
+        cudaGraphNodeTypeMemcpy = 1
+        cudaGraphNodeTypeMemset = 2
+        cudaGraphNodeTypeHost = 3
+        cudaGraphNodeTypeGraph = 4
+        cudaGraphNodeTypeEmpty = 5
+        cudaGraphNodeTypeWaitEvent = 6
+        cudaGraphNodeTypeEventRecord = 7
+        cudaGraphNodeTypeExtSemaphoreSignal = 8
+        cudaGraphNodeTypeExtSemaphoreWait = 9
+        cudaGraphNodeTypeMemAlloc = 10
+        cudaGraphNodeTypeMemFree = 11
+        cudaGraphNodeTypeCount = 12
+
+    cdef enum cudaGraphExecUpdateResult:
+        cudaGraphExecUpdateSuccess = 0
+        cudaGraphExecUpdateError = 1
+        cudaGraphExecUpdateErrorTopologyChanged = 2
+        cudaGraphExecUpdateErrorNodeTypeChanged = 3
+        cudaGraphExecUpdateErrorFunctionChanged = 4
+        cudaGraphExecUpdateErrorParametersChanged = 5
+        cudaGraphExecUpdateErrorNotSupported = 6
+        cudaGraphExecUpdateErrorUnsupportedFunctionChange = 7
+        cudaGraphExecUpdateErrorAttributesChanged = 8
+
+    cdef enum cudaGetDriverEntryPointFlags:
+        cudaEnableDefault = 0
+        cudaEnableLegacyStream = 1
+        cudaEnablePerThreadDefaultStream = 2
+
+    cdef enum cudaGraphDebugDotFlags:
+        cudaGraphDebugDotFlagsVerbose = 1
+        cudaGraphDebugDotFlagsKernelNodeParams = 4
+        cudaGraphDebugDotFlagsMemcpyNodeParams = 8
+        cudaGraphDebugDotFlagsMemsetNodeParams = 16
+        cudaGraphDebugDotFlagsHostNodeParams = 32
+        cudaGraphDebugDotFlagsEventNodeParams = 64
+        cudaGraphDebugDotFlagsExtSemasSignalNodeParams = 128
+        cudaGraphDebugDotFlagsExtSemasWaitNodeParams = 256
+        cudaGraphDebugDotFlagsKernelNodeAttributes = 512
+        cudaGraphDebugDotFlagsHandles = 1024
+
+    cdef enum cudaGraphInstantiateFlags:
+        cudaGraphInstantiateFlagAutoFreeOnLaunch = 1
+        cudaGraphInstantiateFlagUseNodePriority = 8
 
-cdef extern from "cuda_runtime.h":
+cdef extern from "surface_types.h":
 
-    cdef enum cudaRoundMode:
-        cudaRoundNearest = 0
-        cudaRoundZero = 1
-        cudaRoundPosInf = 2
-        cudaRoundMinInf = 3
+    ctypedef unsigned long long cudaSurfaceObject_t
 
     cdef enum cudaSurfaceBoundaryMode:
         cudaBoundaryModeZero = 0
@@ -1172,21 +1078,7 @@ cdef extern from "cuda_runtime.h":
         cudaFormatModeForced = 0
         cudaFormatModeAuto = 1
 
-    ctypedef unsigned long long cudaSurfaceObject_t
-
-    cdef enum cudaTextureAddressMode:
-        cudaAddressModeWrap = 0
-        cudaAddressModeClamp = 1
-        cudaAddressModeMirror = 2
-        cudaAddressModeBorder = 3
-
-    cdef enum cudaTextureFilterMode:
-        cudaFilterModePoint = 0
-        cudaFilterModeLinear = 1
-
-    cdef enum cudaTextureReadMode:
-        cudaReadModeElementType = 0
-        cudaReadModeNormalizedFloat = 1
+cdef extern from "texture_types.h":
 
     cdef struct cudaTextureDesc:
         cudaTextureAddressMode addressMode[3]
@@ -1219,31 +1111,47 @@ cdef extern from "cuda_runtime.h":
 
     ctypedef unsigned long long cudaTextureObject_t
 
+    cdef enum cudaTextureAddressMode:
+        cudaAddressModeWrap = 0
+        cudaAddressModeClamp = 1
+        cudaAddressModeMirror = 2
+        cudaAddressModeBorder = 3
+
+    cdef enum cudaTextureFilterMode:
+        cudaFilterModePoint = 0
+        cudaFilterModeLinear = 1
+
+    cdef enum cudaTextureReadMode:
+        cudaReadModeElementType = 0
+        cudaReadModeNormalizedFloat = 1
+
+cdef extern from "library_types.h":
+
     cdef enum cudaDataType_t:
+        CUDA_R_32F = 0
+        CUDA_R_64F = 1
         CUDA_R_16F = 2
+        CUDA_R_8I = 3
+        CUDA_C_32F = 4
+        CUDA_C_64F = 5
         CUDA_C_16F = 6
+        CUDA_C_8I = 7
+        CUDA_R_8U = 8
+        CUDA_C_8U = 9
+        CUDA_R_32I = 10
+        CUDA_C_32I = 11
+        CUDA_R_32U = 12
+        CUDA_C_32U = 13
         CUDA_R_16BF = 14
         CUDA_C_16BF = 15
-        CUDA_R_32F = 0
-        CUDA_C_32F = 4
-        CUDA_R_64F = 1
-        CUDA_C_64F = 5
         CUDA_R_4I = 16
         CUDA_C_4I = 17
         CUDA_R_4U = 18
         CUDA_C_4U = 19
-        CUDA_R_8I = 3
-        CUDA_C_8I = 7
-        CUDA_R_8U = 8
-        CUDA_C_8U = 9
         CUDA_R_16I = 20
         CUDA_C_16I = 21
         CUDA_R_16U = 22
         CUDA_C_16U = 23
-        CUDA_R_32I = 10
-        CUDA_C_32I = 11
-        CUDA_R_32U = 12
-        CUDA_C_32U = 13
         CUDA_R_64I = 24
         CUDA_C_64I = 25
         CUDA_R_64U = 26
@@ -1251,16 +1159,228 @@ cdef extern from "cuda_runtime.h":
         CUDA_R_8F_E4M3 = 28
         CUDA_R_8F_E5M2 = 29
 
-    ctypedef cudaDataType_t cudaDataType
+    ctypedef cudaDataType_t cudaDataType
+
+    cdef enum libraryPropertyType_t:
+        MAJOR_VERSION = 0
+        MINOR_VERSION = 1
+        PATCH_LEVEL = 2
+
+    ctypedef libraryPropertyType_t libraryPropertyType
+
+cdef extern from "cuda_runtime_api.h":
+
+    ctypedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void* userData)
+
+cdef extern from "device_types.h":
+
+    cdef enum cudaRoundMode:
+        cudaRoundNearest = 0
+        cudaRoundZero = 1
+        cudaRoundPosInf = 2
+        cudaRoundMinInf = 3
+
+ctypedef unsigned int GLenum
+
+ctypedef unsigned int GLuint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLImageKHR
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLStreamKHR
+
+ctypedef unsigned int EGLint
+
+cdef extern from "":
+    cdef struct void:
+        pass
+ctypedef void* EGLSyncKHR
+
+ctypedef uint32_t VdpDevice
+
+ctypedef unsigned long long VdpGetProcAddress
+
+ctypedef uint32_t VdpVideoSurface
+
+ctypedef uint32_t VdpOutputSurface
+
+ctypedef cudaLaunchAttributeID cudaStreamAttrID
+
+ctypedef cudaLaunchAttributeID cudaKernelNodeAttrID
+
+ctypedef cudaLaunchAttributeValue cudaStreamAttrValue
+
+ctypedef cudaLaunchAttributeValue cudaKernelNodeAttrValue
+
+cdef enum cudaEglFrameType_enum:
+    cudaEglFrameTypeArray = 0
+    cudaEglFrameTypePitch = 1
+
+ctypedef cudaEglFrameType_enum cudaEglFrameType
+
+cdef enum cudaEglResourceLocationFlags_enum:
+    cudaEglResourceLocationSysmem = 0
+    cudaEglResourceLocationVidmem = 1
+
+ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags
+
+cdef enum cudaEglColorFormat_enum:
+    cudaEglColorFormatYUV420Planar = 0
+    cudaEglColorFormatYUV420SemiPlanar = 1
+    cudaEglColorFormatYUV422Planar = 2
+    cudaEglColorFormatYUV422SemiPlanar = 3
+    cudaEglColorFormatARGB = 6
+    cudaEglColorFormatRGBA = 7
+    cudaEglColorFormatL = 8
+    cudaEglColorFormatR = 9
+    cudaEglColorFormatYUV444Planar = 10
+    cudaEglColorFormatYUV444SemiPlanar = 11
+    cudaEglColorFormatYUYV422 = 12
+    cudaEglColorFormatUYVY422 = 13
+    cudaEglColorFormatABGR = 14
+    cudaEglColorFormatBGRA = 15
+    cudaEglColorFormatA = 16
+    cudaEglColorFormatRG = 17
+    cudaEglColorFormatAYUV = 18
+    cudaEglColorFormatYVU444SemiPlanar = 19
+    cudaEglColorFormatYVU422SemiPlanar = 20
+    cudaEglColorFormatYVU420SemiPlanar = 21
+    cudaEglColorFormatY10V10U10_444SemiPlanar = 22
+    cudaEglColorFormatY10V10U10_420SemiPlanar = 23
+    cudaEglColorFormatY12V12U12_444SemiPlanar = 24
+    cudaEglColorFormatY12V12U12_420SemiPlanar = 25
+    cudaEglColorFormatVYUY_ER = 26
+    cudaEglColorFormatUYVY_ER = 27
+    cudaEglColorFormatYUYV_ER = 28
+    cudaEglColorFormatYVYU_ER = 29
+    cudaEglColorFormatYUVA_ER = 31
+    cudaEglColorFormatAYUV_ER = 32
+    cudaEglColorFormatYUV444Planar_ER = 33
+    cudaEglColorFormatYUV422Planar_ER = 34
+    cudaEglColorFormatYUV420Planar_ER = 35
+    cudaEglColorFormatYUV444SemiPlanar_ER = 36
+    cudaEglColorFormatYUV422SemiPlanar_ER = 37
+    cudaEglColorFormatYUV420SemiPlanar_ER = 38
+    cudaEglColorFormatYVU444Planar_ER = 39
+    cudaEglColorFormatYVU422Planar_ER = 40
+    cudaEglColorFormatYVU420Planar_ER = 41
+    cudaEglColorFormatYVU444SemiPlanar_ER = 42
+    cudaEglColorFormatYVU422SemiPlanar_ER = 43
+    cudaEglColorFormatYVU420SemiPlanar_ER = 44
+    cudaEglColorFormatBayerRGGB = 45
+    cudaEglColorFormatBayerBGGR = 46
+    cudaEglColorFormatBayerGRBG = 47
+    cudaEglColorFormatBayerGBRG = 48
+    cudaEglColorFormatBayer10RGGB = 49
+    cudaEglColorFormatBayer10BGGR = 50
+    cudaEglColorFormatBayer10GRBG = 51
+    cudaEglColorFormatBayer10GBRG = 52
+    cudaEglColorFormatBayer12RGGB = 53
+    cudaEglColorFormatBayer12BGGR = 54
+    cudaEglColorFormatBayer12GRBG = 55
+    cudaEglColorFormatBayer12GBRG = 56
+    cudaEglColorFormatBayer14RGGB = 57
+    cudaEglColorFormatBayer14BGGR = 58
+    cudaEglColorFormatBayer14GRBG = 59
+    cudaEglColorFormatBayer14GBRG = 60
+    cudaEglColorFormatBayer20RGGB = 61
+    cudaEglColorFormatBayer20BGGR = 62
+    cudaEglColorFormatBayer20GRBG = 63
+    cudaEglColorFormatBayer20GBRG = 64
+    cudaEglColorFormatYVU444Planar = 65
+    cudaEglColorFormatYVU422Planar = 66
+    cudaEglColorFormatYVU420Planar = 67
+    cudaEglColorFormatBayerIspRGGB = 68
+    cudaEglColorFormatBayerIspBGGR = 69
+    cudaEglColorFormatBayerIspGRBG = 70
+    cudaEglColorFormatBayerIspGBRG = 71
+    cudaEglColorFormatBayerBCCR = 72
+    cudaEglColorFormatBayerRCCB = 73
+    cudaEglColorFormatBayerCRBC = 74
+    cudaEglColorFormatBayerCBRC = 75
+    cudaEglColorFormatBayer10CCCC = 76
+    cudaEglColorFormatBayer12BCCR = 77
+    cudaEglColorFormatBayer12RCCB = 78
+    cudaEglColorFormatBayer12CRBC = 79
+    cudaEglColorFormatBayer12CBRC = 80
+    cudaEglColorFormatBayer12CCCC = 81
+    cudaEglColorFormatY = 82
+    cudaEglColorFormatYUV420SemiPlanar_2020 = 83
+    cudaEglColorFormatYVU420SemiPlanar_2020 = 84
+    cudaEglColorFormatYUV420Planar_2020 = 85
+    cudaEglColorFormatYVU420Planar_2020 = 86
+    cudaEglColorFormatYUV420SemiPlanar_709 = 87
+    cudaEglColorFormatYVU420SemiPlanar_709 = 88
+    cudaEglColorFormatYUV420Planar_709 = 89
+    cudaEglColorFormatYVU420Planar_709 = 90
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91
+    cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92
+    cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93
+    cudaEglColorFormatY10V10U10_422SemiPlanar = 94
+    cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95
+    cudaEglColorFormatY_ER = 96
+    cudaEglColorFormatY_709_ER = 97
+    cudaEglColorFormatY10_ER = 98
+    cudaEglColorFormatY10_709_ER = 99
+    cudaEglColorFormatY12_ER = 100
+    cudaEglColorFormatY12_709_ER = 101
+    cudaEglColorFormatYUVA = 102
+    cudaEglColorFormatYVYU = 104
+    cudaEglColorFormatVYUY = 105
+    cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107
+    cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108
+    cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109
+    cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110
+    cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111
+    cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112
+    cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113
+
+ctypedef cudaEglColorFormat_enum cudaEglColorFormat
+
+cdef struct cudaEglPlaneDesc_st:
+    unsigned int width
+    unsigned int height
+    unsigned int depth
+    unsigned int pitch
+    unsigned int numChannels
+    cudaChannelFormatDesc channelDesc
+    unsigned int reserved[4]
+
+ctypedef cudaEglPlaneDesc_st cudaEglPlaneDesc
+
+cdef union anon_union7:
+    cudaArray_t pArray[3]
+    cudaPitchedPtr pPitch[3]
+
+cdef struct cudaEglFrame_st:
+    anon_union7 frame
+    cudaEglPlaneDesc planeDesc[3]
+    unsigned int planeCount
+    cudaEglFrameType frameType
+    cudaEglColorFormat eglColorFormat
 
-    cdef enum libraryPropertyType_t:
-        MAJOR_VERSION = 0
-        MINOR_VERSION = 1
-        PATCH_LEVEL = 2
+ctypedef cudaEglFrame_st cudaEglFrame
 
-    ctypedef libraryPropertyType_t libraryPropertyType
+cdef extern from "":
+    cdef struct CUeglStreamConnection_st:
+        pass
+ctypedef CUeglStreamConnection_st* cudaEglStreamConnection
 
-    ctypedef void (*cudaStreamCallback_t)(cudaStream_t stream, cudaError_t status, void* userData)
+cdef enum cudaGLDeviceList:
+    cudaGLDeviceListAll = 1
+    cudaGLDeviceListCurrentFrame = 2
+    cudaGLDeviceListNextFrame = 3
+
+cdef enum cudaGLMapFlags:
+    cudaGLMapFlagsNone = 0
+    cudaGLMapFlagsReadOnly = 1
+    cudaGLMapFlagsWriteDiscard = 2
 
 {{if 'cudaDeviceReset' in found_functions}}
 
@@ -1352,26 +1472,6 @@ cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequir
 cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if 'cudaThreadExit' in found_functions}}
-
-cdef cudaError_t cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
-{{if 'cudaThreadSynchronize' in found_functions}}
-
-cdef cudaError_t cudaThreadSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
-{{if 'cudaThreadSetLimit' in found_functions}}
-
-cdef cudaError_t cudaThreadSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
-{{if 'cudaThreadGetLimit' in found_functions}}
-
-cdef cudaError_t cudaThreadGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
 {{if 'cudaGetLastError' in found_functions}}
 
 cdef cudaError_t cudaGetLastError() except ?cudaErrorCallRequiresNewerDriver nogil
@@ -1667,16 +1767,6 @@ cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* fun
 cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if 'cudaSetDoubleForDevice' in found_functions}}
-
-cdef cudaError_t cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
-{{if 'cudaSetDoubleForHost' in found_functions}}
-
-cdef cudaError_t cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil
-{{endif}}
-
 {{if 'cudaLaunchHostFunc' in found_functions}}
 
 cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil
@@ -2572,236 +2662,114 @@ cdef cudaPos make_cudaPos(size_t x, size_t y, size_t z) nogil
 cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil
 {{endif}}
 
+{{if True}}
 
-{{if True or 'cudaProfilerInitialize' in found_functions}}
-
-cdef cudaError_t cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaProfilerStart' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaProfilerStop' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
+{{if True}}
 
-cdef enum cudaEglFrameType_enum:
-    cudaEglFrameTypeArray = 0
-    cudaEglFrameTypePitch = 1
+cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-ctypedef cudaEglFrameType_enum cudaEglFrameType
+{{if True}}
 
-cdef enum cudaEglResourceLocationFlags_enum:
-    cudaEglResourceLocationSysmem = 0
-    cudaEglResourceLocationVidmem = 1
+cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-ctypedef cudaEglResourceLocationFlags_enum cudaEglResourceLocationFlags
+{{if True}}
 
-cdef enum cudaEglColorFormat_enum:
-    cudaEglColorFormatYUV420Planar = 0
-    cudaEglColorFormatYUV420SemiPlanar = 1
-    cudaEglColorFormatYUV422Planar = 2
-    cudaEglColorFormatYUV422SemiPlanar = 3
-    cudaEglColorFormatARGB = 6
-    cudaEglColorFormatRGBA = 7
-    cudaEglColorFormatL = 8
-    cudaEglColorFormatR = 9
-    cudaEglColorFormatYUV444Planar = 10
-    cudaEglColorFormatYUV444SemiPlanar = 11
-    cudaEglColorFormatYUYV422 = 12
-    cudaEglColorFormatUYVY422 = 13
-    cudaEglColorFormatABGR = 14
-    cudaEglColorFormatBGRA = 15
-    cudaEglColorFormatA = 16
-    cudaEglColorFormatRG = 17
-    cudaEglColorFormatAYUV = 18
-    cudaEglColorFormatYVU444SemiPlanar = 19
-    cudaEglColorFormatYVU422SemiPlanar = 20
-    cudaEglColorFormatYVU420SemiPlanar = 21
-    cudaEglColorFormatY10V10U10_444SemiPlanar = 22
-    cudaEglColorFormatY10V10U10_420SemiPlanar = 23
-    cudaEglColorFormatY12V12U12_444SemiPlanar = 24
-    cudaEglColorFormatY12V12U12_420SemiPlanar = 25
-    cudaEglColorFormatVYUY_ER = 26
-    cudaEglColorFormatUYVY_ER = 27
-    cudaEglColorFormatYUYV_ER = 28
-    cudaEglColorFormatYVYU_ER = 29
-    cudaEglColorFormatYUVA_ER = 31
-    cudaEglColorFormatAYUV_ER = 32
-    cudaEglColorFormatYUV444Planar_ER = 33
-    cudaEglColorFormatYUV422Planar_ER = 34
-    cudaEglColorFormatYUV420Planar_ER = 35
-    cudaEglColorFormatYUV444SemiPlanar_ER = 36
-    cudaEglColorFormatYUV422SemiPlanar_ER = 37
-    cudaEglColorFormatYUV420SemiPlanar_ER = 38
-    cudaEglColorFormatYVU444Planar_ER = 39
-    cudaEglColorFormatYVU422Planar_ER = 40
-    cudaEglColorFormatYVU420Planar_ER = 41
-    cudaEglColorFormatYVU444SemiPlanar_ER = 42
-    cudaEglColorFormatYVU422SemiPlanar_ER = 43
-    cudaEglColorFormatYVU420SemiPlanar_ER = 44
-    cudaEglColorFormatBayerRGGB = 45
-    cudaEglColorFormatBayerBGGR = 46
-    cudaEglColorFormatBayerGRBG = 47
-    cudaEglColorFormatBayerGBRG = 48
-    cudaEglColorFormatBayer10RGGB = 49
-    cudaEglColorFormatBayer10BGGR = 50
-    cudaEglColorFormatBayer10GRBG = 51
-    cudaEglColorFormatBayer10GBRG = 52
-    cudaEglColorFormatBayer12RGGB = 53
-    cudaEglColorFormatBayer12BGGR = 54
-    cudaEglColorFormatBayer12GRBG = 55
-    cudaEglColorFormatBayer12GBRG = 56
-    cudaEglColorFormatBayer14RGGB = 57
-    cudaEglColorFormatBayer14BGGR = 58
-    cudaEglColorFormatBayer14GRBG = 59
-    cudaEglColorFormatBayer14GBRG = 60
-    cudaEglColorFormatBayer20RGGB = 61
-    cudaEglColorFormatBayer20BGGR = 62
-    cudaEglColorFormatBayer20GRBG = 63
-    cudaEglColorFormatBayer20GBRG = 64
-    cudaEglColorFormatYVU444Planar = 65
-    cudaEglColorFormatYVU422Planar = 66
-    cudaEglColorFormatYVU420Planar = 67
-    cudaEglColorFormatBayerIspRGGB = 68
-    cudaEglColorFormatBayerIspBGGR = 69
-    cudaEglColorFormatBayerIspGRBG = 70
-    cudaEglColorFormatBayerIspGBRG = 71
-    cudaEglColorFormatBayerBCCR = 72
-    cudaEglColorFormatBayerRCCB = 73
-    cudaEglColorFormatBayerCRBC = 74
-    cudaEglColorFormatBayerCBRC = 75
-    cudaEglColorFormatBayer10CCCC = 76
-    cudaEglColorFormatBayer12BCCR = 77
-    cudaEglColorFormatBayer12RCCB = 78
-    cudaEglColorFormatBayer12CRBC = 79
-    cudaEglColorFormatBayer12CBRC = 80
-    cudaEglColorFormatBayer12CCCC = 81
-    cudaEglColorFormatY = 82
-    cudaEglColorFormatYUV420SemiPlanar_2020 = 83
-    cudaEglColorFormatYVU420SemiPlanar_2020 = 84
-    cudaEglColorFormatYUV420Planar_2020 = 85
-    cudaEglColorFormatYVU420Planar_2020 = 86
-    cudaEglColorFormatYUV420SemiPlanar_709 = 87
-    cudaEglColorFormatYVU420SemiPlanar_709 = 88
-    cudaEglColorFormatYUV420Planar_709 = 89
-    cudaEglColorFormatYVU420Planar_709 = 90
-    cudaEglColorFormatY10V10U10_420SemiPlanar_709 = 91
-    cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = 92
-    cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = 93
-    cudaEglColorFormatY10V10U10_422SemiPlanar = 94
-    cudaEglColorFormatY10V10U10_422SemiPlanar_709 = 95
-    cudaEglColorFormatY_ER = 96
-    cudaEglColorFormatY_709_ER = 97
-    cudaEglColorFormatY10_ER = 98
-    cudaEglColorFormatY10_709_ER = 99
-    cudaEglColorFormatY12_ER = 100
-    cudaEglColorFormatY12_709_ER = 101
-    cudaEglColorFormatYUVA = 102
-    cudaEglColorFormatYVYU = 104
-    cudaEglColorFormatVYUY = 105
-    cudaEglColorFormatY10V10U10_420SemiPlanar_ER = 106
-    cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = 107
-    cudaEglColorFormatY10V10U10_444SemiPlanar_ER = 108
-    cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = 109
-    cudaEglColorFormatY12V12U12_420SemiPlanar_ER = 110
-    cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = 111
-    cudaEglColorFormatY12V12U12_444SemiPlanar_ER = 112
-    cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = 113
+cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-ctypedef cudaEglColorFormat_enum cudaEglColorFormat
+{{if True}}
 
-cdef struct cudaEglPlaneDesc_st:
-    unsigned int width
-    unsigned int height
-    unsigned int depth
-    unsigned int pitch
-    unsigned int numChannels
-    cudaChannelFormatDesc channelDesc
-    unsigned int reserved[4]
+cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-ctypedef cudaEglPlaneDesc_st cudaEglPlaneDesc
+{{if True}}
 
-cdef union _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
-    cudaArray_t pArray[3]
-    cudaPitchedPtr pPitch[3]
+cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-cdef struct cudaEglFrame_st:
-    _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u frame
-    cudaEglPlaneDesc planeDesc[3]
-    unsigned int planeCount
-    cudaEglFrameType frameType
-    cudaEglColorFormat eglColorFormat
+{{if True}}
 
-ctypedef cudaEglFrame_st cudaEglFrame
+cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-cdef extern from "":
-    cdef struct CUeglStreamConnection_st:
-        pass
-ctypedef CUeglStreamConnection_st* cudaEglStreamConnection
+{{if True}}
+
+cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+{{endif}}
 
-{{if True or 'cudaGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
-{{if True or 'cudaEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
+cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil
 {{endif}}
 
 {{if True}}
@@ -2921,6 +2889,16 @@ cdef enum: cudaNvSciSyncAttrSignal = 1
 
 cdef enum: cudaNvSciSyncAttrWait = 2
 
+cdef enum: cudaStreamAttributeAccessPolicyWindow = 1
+
+cdef enum: cudaStreamAttributeSynchronizationPolicy = 3
+
+cdef enum: cudaKernelNodeAttributeAccessPolicyWindow = 1
+
+cdef enum: cudaKernelNodeAttributeCooperative = 2
+
+cdef enum: cudaKernelNodeAttributePriority = 8
+
 cdef enum: cudaKernelNodeAttributeClusterDimension = 4
 
 cdef enum: cudaKernelNodeAttributeClusterSchedulingPolicyPreference = 5
@@ -2957,4 +2935,4 @@ cdef enum: CUDART_VERSION = 11080
 
 cdef enum: __CUDART_API_VERSION = 11080
 
-cdef enum: CUDA_EGL_MAX_PLANES = 3
+cdef enum: CUDA_EGL_MAX_PLANES = 3
\ No newline at end of file
diff --git a/cuda/ccudart.pyx.in b/cuda/cuda/bindings/cyruntime.pyx.in
similarity index 60%
rename from cuda/ccudart.pyx.in
rename to cuda/cuda/bindings/cyruntime.pyx.in
index df320d24..a8aa23a5 100644
--- a/cuda/ccudart.pyx.in
+++ b/cuda/cuda/bindings/cyruntime.pyx.in
@@ -1,110 +1,22 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda._cuda.ccuda as ccuda
-from cuda._lib.ccudart.ccudart cimport *
-from cuda._lib.ccudart.utils cimport *
+
+# cython: show_performance_hints=False
+
+cimport cuda.bindings._bindings.cydriver as cydriver
+from cuda.bindings._lib.cyruntime.cyruntime cimport *
+from cuda.bindings._lib.cyruntime.utils cimport *
 from libc.stdlib cimport malloc, free, calloc
-from libc.string cimport memset, memcpy, strncmp
+from libc cimport string
 from libcpp cimport bool
 
 cdef cudaPythonGlobal m_global = globalGetInstance()
 
-{{if True or 'cudaVDPAUGetDevice' in found_functions}}
-
-cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuVDPAUGetDevice(<ccuda.CUdevice*>device, vdpDevice, vdpGetProcAddress)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaVDPAUSetVDPAUDevice' in found_functions}}
-
-cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress)
-
-{{endif}}
-
-{{if True or 'cudaGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsVDPAURegisterVideoSurface(<ccuda.CUgraphicsResource*>resource, vdpSurface, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsVDPAURegisterOutputSurface(<ccuda.CUgraphicsResource*>resource, vdpSurface, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaGLGetDevices' in found_functions}}
-
-cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGLGetDevices_v2(pCudaDeviceCount, <ccuda.CUdevice*>pCudaDevices, cudaDeviceCount, <ccuda.CUGLDeviceList>deviceList)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaGraphicsGLRegisterImage' in found_functions}}
-
-cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsGLRegisterImage(<ccuda.CUgraphicsResource*>resource, image, target, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaGraphicsGLRegisterBuffer' in found_functions}}
-
-cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsGLRegisterBuffer(<ccuda.CUgraphicsResource*>resource, buffer, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
 {{if 'cudaDeviceReset' in found_functions}}
 
 cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogil:
@@ -115,42 +27,21 @@ cdef cudaError_t cudaDeviceReset() except ?cudaErrorCallRequiresNewerDriver nogi
 {{if 'cudaDeviceSynchronize' in found_functions}}
 
 cdef cudaError_t cudaDeviceSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSynchronize()
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSynchronize()
 
 {{endif}}
 
 {{if 'cudaDeviceSetLimit' in found_functions}}
 
 cdef cudaError_t cudaDeviceSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSetLimit(<ccuda.CUlimit>limit, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSetLimit(limit, value)
 
 {{endif}}
 
 {{if 'cudaDeviceGetLimit' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetLimit(pValue, <ccuda.CUlimit>limit)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetLimit(pValue, limit)
 
 {{endif}}
 
@@ -164,70 +55,35 @@ cdef cudaError_t cudaDeviceGetTexture1DLinearMaxWidth(size_t* maxWidthInElements
 {{if 'cudaDeviceGetCacheConfig' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetCacheConfig(cudaFuncCache* pCacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetCacheConfig(<ccuda.CUfunc_cache*>pCacheConfig)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetCacheConfig(pCacheConfig)
 
 {{endif}}
 
 {{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetStreamPriorityRange(int* leastPriority, int* greatestPriority) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetStreamPriorityRange(leastPriority, greatestPriority)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetStreamPriorityRange(leastPriority, greatestPriority)
 
 {{endif}}
 
 {{if 'cudaDeviceSetCacheConfig' in found_functions}}
 
 cdef cudaError_t cudaDeviceSetCacheConfig(cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSetCacheConfig(<ccuda.CUfunc_cache>cacheConfig)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSetCacheConfig(cacheConfig)
 
 {{endif}}
 
 {{if 'cudaDeviceGetSharedMemConfig' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetSharedMemConfig(cudaSharedMemConfig* pConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetSharedMemConfig(<ccuda.CUsharedconfig*>pConfig)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetSharedMemConfig(pConfig)
 
 {{endif}}
 
 {{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
 
 cdef cudaError_t cudaDeviceSetSharedMemConfig(cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSetSharedMemConfig(<ccuda.CUsharedconfig>config)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSetSharedMemConfig(config)
 
 {{endif}}
 
@@ -248,137 +104,42 @@ cdef cudaError_t cudaDeviceGetPCIBusId(char* pciBusId, int length, int device) e
 {{if 'cudaIpcGetEventHandle' in found_functions}}
 
 cdef cudaError_t cudaIpcGetEventHandle(cudaIpcEventHandle_t* handle, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuIpcGetEventHandle(<ccuda.CUipcEventHandle*>handle, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaIpcGetEventHandle(handle, event)
 
 {{endif}}
 
 {{if 'cudaIpcOpenEventHandle' in found_functions}}
 
 cdef cudaError_t cudaIpcOpenEventHandle(cudaEvent_t* event, cudaIpcEventHandle_t handle) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUipcEventHandle _driver_handle
-    memcpy(&_driver_handle, &handle, sizeof(_driver_handle))
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuIpcOpenEventHandle(<ccuda.CUevent*>event, _driver_handle)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaIpcOpenEventHandle(event, handle)
 
 {{endif}}
 
 {{if 'cudaIpcGetMemHandle' in found_functions}}
 
 cdef cudaError_t cudaIpcGetMemHandle(cudaIpcMemHandle_t* handle, void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuIpcGetMemHandle(<ccuda.CUipcMemHandle*>handle, <ccuda.CUdeviceptr>devPtr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaIpcGetMemHandle(handle, devPtr)
 
 {{endif}}
 
 {{if 'cudaIpcOpenMemHandle' in found_functions}}
 
 cdef cudaError_t cudaIpcOpenMemHandle(void** devPtr, cudaIpcMemHandle_t handle, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUipcMemHandle _driver_handle
-    memcpy(&_driver_handle, &handle, sizeof(_driver_handle))
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuIpcOpenMemHandle_v2(<ccuda.CUdeviceptr*>devPtr, _driver_handle, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaIpcOpenMemHandle(devPtr, handle, flags)
 
 {{endif}}
 
 {{if 'cudaIpcCloseMemHandle' in found_functions}}
 
 cdef cudaError_t cudaIpcCloseMemHandle(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuIpcCloseMemHandle(<ccuda.CUdeviceptr>devPtr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaIpcCloseMemHandle(devPtr)
 
 {{endif}}
 
 {{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}
 
 cdef cudaError_t cudaDeviceFlushGPUDirectRDMAWrites(cudaFlushGPUDirectRDMAWritesTarget target, cudaFlushGPUDirectRDMAWritesScope scope) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuFlushGPUDirectRDMAWrites(<ccuda.CUflushGPUDirectRDMAWritesTarget>target, <ccuda.CUflushGPUDirectRDMAWritesScope>scope)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if 'cudaThreadExit' in found_functions}}
-
-cdef cudaError_t cudaThreadExit() except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaThreadExit()
-
-{{endif}}
-
-{{if 'cudaThreadSynchronize' in found_functions}}
-
-cdef cudaError_t cudaThreadSynchronize() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSynchronize()
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if 'cudaThreadSetLimit' in found_functions}}
-
-cdef cudaError_t cudaThreadSetLimit(cudaLimit limit, size_t value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxSetLimit(<ccuda.CUlimit>limit, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if 'cudaThreadGetLimit' in found_functions}}
-
-cdef cudaError_t cudaThreadGetLimit(size_t* pValue, cudaLimit limit) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxGetLimit(pValue, <ccuda.CUlimit>limit)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceFlushGPUDirectRDMAWrites(target, scope)
 
 {{endif}}
 
@@ -810,56 +571,28 @@ cdef cudaError_t cudaDeviceGetAttribute(int* value, cudaDeviceAttr attr, int dev
 {{if 'cudaDeviceGetDefaultMemPool' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetDefaultMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGetDefaultMemPool(<ccuda.CUmemoryPool*>memPool, <ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetDefaultMemPool(memPool, device)
 
 {{endif}}
 
 {{if 'cudaDeviceSetMemPool' in found_functions}}
 
 cdef cudaError_t cudaDeviceSetMemPool(int device, cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceSetMemPool(<ccuda.CUdevice>device, <ccuda.CUmemoryPool>memPool)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSetMemPool(device, memPool)
 
 {{endif}}
 
 {{if 'cudaDeviceGetMemPool' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetMemPool(cudaMemPool_t* memPool, int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGetMemPool(<ccuda.CUmemoryPool*>memPool, <ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetMemPool(memPool, device)
 
 {{endif}}
 
 {{if 'cudaDeviceGetNvSciSyncAttributes' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetNvSciSyncAttributes(void* nvSciSyncAttrList, int device, int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, <ccuda.CUdevice>device, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, device, flags)
 
 {{endif}}
 
@@ -915,84 +648,42 @@ cdef cudaError_t cudaStreamCreate(cudaStream_t* pStream) except ?cudaErrorCallRe
 {{if 'cudaStreamCreateWithFlags' in found_functions}}
 
 cdef cudaError_t cudaStreamCreateWithFlags(cudaStream_t* pStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamCreate(<ccuda.CUstream*>pStream, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamCreateWithFlags(pStream, flags)
 
 {{endif}}
 
 {{if 'cudaStreamCreateWithPriority' in found_functions}}
 
 cdef cudaError_t cudaStreamCreateWithPriority(cudaStream_t* pStream, unsigned int flags, int priority) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamCreateWithPriority(<ccuda.CUstream*>pStream, flags, priority)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamCreateWithPriority(pStream, flags, priority)
 
 {{endif}}
 
 {{if 'cudaStreamGetPriority' in found_functions}}
 
 cdef cudaError_t cudaStreamGetPriority(cudaStream_t hStream, int* priority) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamGetPriority(<ccuda.CUstream>hStream, priority)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamGetPriority(hStream, priority)
 
 {{endif}}
 
 {{if 'cudaStreamGetFlags' in found_functions}}
 
 cdef cudaError_t cudaStreamGetFlags(cudaStream_t hStream, unsigned int* flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamGetFlags(<ccuda.CUstream>hStream, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamGetFlags(hStream, flags)
 
 {{endif}}
 
 {{if 'cudaCtxResetPersistingL2Cache' in found_functions}}
 
 cdef cudaError_t cudaCtxResetPersistingL2Cache() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuCtxResetPersistingL2Cache()
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaCtxResetPersistingL2Cache()
 
 {{endif}}
 
 {{if 'cudaStreamCopyAttributes' in found_functions}}
 
 cdef cudaError_t cudaStreamCopyAttributes(cudaStream_t dst, cudaStream_t src) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamCopyAttributes(<ccuda.CUstream>dst, <ccuda.CUstream>src)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamCopyAttributes(dst, src)
 
 {{endif}}
 
@@ -1013,28 +704,14 @@ cdef cudaError_t cudaStreamSetAttribute(cudaStream_t hStream, cudaStreamAttrID a
 {{if 'cudaStreamDestroy' in found_functions}}
 
 cdef cudaError_t cudaStreamDestroy(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamDestroy_v2(<ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamDestroy(stream)
 
 {{endif}}
 
 {{if 'cudaStreamWaitEvent' in found_functions}}
 
 cdef cudaError_t cudaStreamWaitEvent(cudaStream_t stream, cudaEvent_t event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamWaitEvent(<ccuda.CUstream>stream, <ccuda.CUevent>event, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamWaitEvent(stream, event, flags)
 
 {{endif}}
 
@@ -1048,98 +725,49 @@ cdef cudaError_t cudaStreamAddCallback(cudaStream_t stream, cudaStreamCallback_t
 {{if 'cudaStreamSynchronize' in found_functions}}
 
 cdef cudaError_t cudaStreamSynchronize(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamSynchronize(<ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamSynchronize(stream)
 
 {{endif}}
 
 {{if 'cudaStreamQuery' in found_functions}}
 
 cdef cudaError_t cudaStreamQuery(cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamQuery(<ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamQuery(stream)
 
 {{endif}}
 
 {{if 'cudaStreamAttachMemAsync' in found_functions}}
 
 cdef cudaError_t cudaStreamAttachMemAsync(cudaStream_t stream, void* devPtr, size_t length, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamAttachMemAsync(<ccuda.CUstream>stream, <ccuda.CUdeviceptr>devPtr, length, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamAttachMemAsync(stream, devPtr, length, flags)
 
 {{endif}}
 
 {{if 'cudaStreamBeginCapture' in found_functions}}
 
 cdef cudaError_t cudaStreamBeginCapture(cudaStream_t stream, cudaStreamCaptureMode mode) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamBeginCapture_v2(<ccuda.CUstream>stream, <ccuda.CUstreamCaptureMode>mode)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamBeginCapture(stream, mode)
 
 {{endif}}
 
 {{if 'cudaThreadExchangeStreamCaptureMode' in found_functions}}
 
 cdef cudaError_t cudaThreadExchangeStreamCaptureMode(cudaStreamCaptureMode* mode) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuThreadExchangeStreamCaptureMode(<ccuda.CUstreamCaptureMode*>mode)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaThreadExchangeStreamCaptureMode(mode)
 
 {{endif}}
 
 {{if 'cudaStreamEndCapture' in found_functions}}
 
 cdef cudaError_t cudaStreamEndCapture(cudaStream_t stream, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamEndCapture(<ccuda.CUstream>stream, <ccuda.CUgraph*>pGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamEndCapture(stream, pGraph)
 
 {{endif}}
 
 {{if 'cudaStreamIsCapturing' in found_functions}}
 
 cdef cudaError_t cudaStreamIsCapturing(cudaStream_t stream, cudaStreamCaptureStatus* pCaptureStatus) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamIsCapturing(<ccuda.CUstream>stream, <ccuda.CUstreamCaptureStatus*>pCaptureStatus)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamIsCapturing(stream, pCaptureStatus)
 
 {{endif}}
 
@@ -1160,14 +788,7 @@ cdef cudaError_t cudaStreamGetCaptureInfo_v2(cudaStream_t stream, cudaStreamCapt
 {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}
 
 cdef cudaError_t cudaStreamUpdateCaptureDependencies(cudaStream_t stream, cudaGraphNode_t* dependencies, size_t numDependencies, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuStreamUpdateCaptureDependencies(<ccuda.CUstream>stream, <ccuda.CUgraphNode*>dependencies, numDependencies, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaStreamUpdateCaptureDependencies(stream, dependencies, numDependencies, flags)
 
 {{endif}}
 
@@ -1181,42 +802,21 @@ cdef cudaError_t cudaEventCreate(cudaEvent_t* event) except ?cudaErrorCallRequir
 {{if 'cudaEventCreateWithFlags' in found_functions}}
 
 cdef cudaError_t cudaEventCreateWithFlags(cudaEvent_t* event, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventCreate(<ccuda.CUevent*>event, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventCreateWithFlags(event, flags)
 
 {{endif}}
 
 {{if 'cudaEventRecord' in found_functions}}
 
 cdef cudaError_t cudaEventRecord(cudaEvent_t event, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventRecord(<ccuda.CUevent>event, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventRecord(event, stream)
 
 {{endif}}
 
 {{if 'cudaEventRecordWithFlags' in found_functions}}
 
 cdef cudaError_t cudaEventRecordWithFlags(cudaEvent_t event, cudaStream_t stream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventRecordWithFlags(<ccuda.CUevent>event, <ccuda.CUstream>stream, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventRecordWithFlags(event, stream, flags)
 
 {{endif}}
 
@@ -1230,42 +830,21 @@ cdef cudaError_t cudaEventQuery(cudaEvent_t event) except ?cudaErrorCallRequires
 {{if 'cudaEventSynchronize' in found_functions}}
 
 cdef cudaError_t cudaEventSynchronize(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventSynchronize(<ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventSynchronize(event)
 
 {{endif}}
 
 {{if 'cudaEventDestroy' in found_functions}}
 
 cdef cudaError_t cudaEventDestroy(cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventDestroy_v2(<ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventDestroy(event)
 
 {{endif}}
 
 {{if 'cudaEventElapsedTime' in found_functions}}
 
 cdef cudaError_t cudaEventElapsedTime(float* ms, cudaEvent_t start, cudaEvent_t end) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventElapsedTime(ms, <ccuda.CUevent>start, <ccuda.CUevent>end)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventElapsedTime(ms, start, end)
 
 {{endif}}
 
@@ -1293,14 +872,7 @@ cdef cudaError_t cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray_t*
 {{if 'cudaDestroyExternalMemory' in found_functions}}
 
 cdef cudaError_t cudaDestroyExternalMemory(cudaExternalMemory_t extMem) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDestroyExternalMemory(<ccuda.CUexternalMemory>extMem)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDestroyExternalMemory(extMem)
 
 {{endif}}
 
@@ -1314,56 +886,35 @@ cdef cudaError_t cudaImportExternalSemaphore(cudaExternalSemaphore_t* extSem_out
 {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}
 
 cdef cudaError_t cudaSignalExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreSignalParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaSignalExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
+    return _cudaSignalExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)
 
 {{endif}}
 
 {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}
 
 cdef cudaError_t cudaWaitExternalSemaphoresAsync(const cudaExternalSemaphore_t* extSemArray, const cudaExternalSemaphoreWaitParams* paramsArray, unsigned int numExtSems, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaWaitExternalSemaphoresAsync(extSemArray, paramsArray, numExtSems, stream)
+    return _cudaWaitExternalSemaphoresAsync_v2(extSemArray, paramsArray, numExtSems, stream)
 
 {{endif}}
 
 {{if 'cudaDestroyExternalSemaphore' in found_functions}}
 
 cdef cudaError_t cudaDestroyExternalSemaphore(cudaExternalSemaphore_t extSem) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDestroyExternalSemaphore(<ccuda.CUexternalSemaphore>extSem)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDestroyExternalSemaphore(extSem)
 
 {{endif}}
 
 {{if 'cudaFuncSetCacheConfig' in found_functions}}
 
 cdef cudaError_t cudaFuncSetCacheConfig(const void* func, cudaFuncCache cacheConfig) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuFuncSetCacheConfig(<ccuda.CUfunction>func, <ccuda.CUfunc_cache>cacheConfig)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFuncSetCacheConfig(func, cacheConfig)
 
 {{endif}}
 
 {{if 'cudaFuncSetSharedMemConfig' in found_functions}}
 
 cdef cudaError_t cudaFuncSetSharedMemConfig(const void* func, cudaSharedMemConfig config) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuFuncSetSharedMemConfig(<ccuda.CUfunction>func, <ccuda.CUsharedconfig>config)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFuncSetSharedMemConfig(func, config)
 
 {{endif}}
 
@@ -1377,112 +928,49 @@ cdef cudaError_t cudaFuncGetAttributes(cudaFuncAttributes* attr, const void* fun
 {{if 'cudaFuncSetAttribute' in found_functions}}
 
 cdef cudaError_t cudaFuncSetAttribute(const void* func, cudaFuncAttribute attr, int value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuFuncSetAttribute(<ccuda.CUfunction>func, <ccuda.CUfunction_attribute>attr, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if 'cudaSetDoubleForDevice' in found_functions}}
-
-cdef cudaError_t cudaSetDoubleForDevice(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaSetDoubleForDevice(d)
-
-{{endif}}
-
-{{if 'cudaSetDoubleForHost' in found_functions}}
-
-cdef cudaError_t cudaSetDoubleForHost(double* d) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaSetDoubleForHost(d)
+    return _cudaFuncSetAttribute(func, attr, value)
 
 {{endif}}
 
 {{if 'cudaLaunchHostFunc' in found_functions}}
 
 cdef cudaError_t cudaLaunchHostFunc(cudaStream_t stream, cudaHostFn_t fn, void* userData) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuLaunchHostFunc(<ccuda.CUstream>stream, <ccuda.CUhostFn>fn, userData)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaLaunchHostFunc(stream, fn, userData)
 
 {{endif}}
 
 {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessor' in found_functions}}
 
 cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessor(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, <ccuda.CUfunction>func, blockSize, dynamicSMemSize)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaOccupancyMaxActiveBlocksPerMultiprocessor(numBlocks, func, blockSize, dynamicSMemSize)
 
 {{endif}}
 
 {{if 'cudaOccupancyAvailableDynamicSMemPerBlock' in found_functions}}
 
 cdef cudaError_t cudaOccupancyAvailableDynamicSMemPerBlock(size_t* dynamicSmemSize, const void* func, int numBlocks, int blockSize) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, <ccuda.CUfunction>func, numBlocks, blockSize)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaOccupancyAvailableDynamicSMemPerBlock(dynamicSmemSize, func, numBlocks, blockSize)
 
 {{endif}}
 
 {{if 'cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags' in found_functions}}
 
 cdef cudaError_t cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int* numBlocks, const void* func, int blockSize, size_t dynamicSMemSize, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, <ccuda.CUfunction>func, blockSize, dynamicSMemSize, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(numBlocks, func, blockSize, dynamicSMemSize, flags)
 
 {{endif}}
 
 {{if 'cudaMallocManaged' in found_functions}}
 
 cdef cudaError_t cudaMallocManaged(void** devPtr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemAllocManaged(<ccuda.CUdeviceptr*>devPtr, size, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMallocManaged(devPtr, size, flags)
 
 {{endif}}
 
 {{if 'cudaMalloc' in found_functions}}
 
 cdef cudaError_t cudaMalloc(void** devPtr, size_t size) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemAlloc_v2(<ccuda.CUdeviceptr*>devPtr, size)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMalloc(devPtr, size)
 
 {{endif}}
 
@@ -1510,126 +998,63 @@ cdef cudaError_t cudaMallocArray(cudaArray_t* array, const cudaChannelFormatDesc
 {{if 'cudaFree' in found_functions}}
 
 cdef cudaError_t cudaFree(void* devPtr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemFree_v2(<ccuda.CUdeviceptr>devPtr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFree(devPtr)
 
 {{endif}}
 
 {{if 'cudaFreeHost' in found_functions}}
 
 cdef cudaError_t cudaFreeHost(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemFreeHost(ptr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFreeHost(ptr)
 
 {{endif}}
 
 {{if 'cudaFreeArray' in found_functions}}
 
 cdef cudaError_t cudaFreeArray(cudaArray_t array) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuArrayDestroy(<ccuda.CUarray>array)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFreeArray(array)
 
 {{endif}}
 
 {{if 'cudaFreeMipmappedArray' in found_functions}}
 
 cdef cudaError_t cudaFreeMipmappedArray(cudaMipmappedArray_t mipmappedArray) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMipmappedArrayDestroy(<ccuda.CUmipmappedArray>mipmappedArray)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFreeMipmappedArray(mipmappedArray)
 
 {{endif}}
 
 {{if 'cudaHostAlloc' in found_functions}}
 
 cdef cudaError_t cudaHostAlloc(void** pHost, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemHostAlloc(pHost, size, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaHostAlloc(pHost, size, flags)
 
 {{endif}}
 
 {{if 'cudaHostRegister' in found_functions}}
 
 cdef cudaError_t cudaHostRegister(void* ptr, size_t size, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemHostRegister_v2(ptr, size, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaHostRegister(ptr, size, flags)
 
 {{endif}}
 
 {{if 'cudaHostUnregister' in found_functions}}
 
 cdef cudaError_t cudaHostUnregister(void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemHostUnregister(ptr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaHostUnregister(ptr)
 
 {{endif}}
 
 {{if 'cudaHostGetDevicePointer' in found_functions}}
 
 cdef cudaError_t cudaHostGetDevicePointer(void** pDevice, void* pHost, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemHostGetDevicePointer_v2(<ccuda.CUdeviceptr*>pDevice, pHost, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaHostGetDevicePointer(pDevice, pHost, flags)
 
 {{endif}}
 
 {{if 'cudaHostGetFlags' in found_functions}}
 
 cdef cudaError_t cudaHostGetFlags(unsigned int* pFlags, void* pHost) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemHostGetFlags(pFlags, pHost)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaHostGetFlags(pFlags, pHost)
 
 {{endif}}
 
@@ -1657,14 +1082,7 @@ cdef cudaError_t cudaMallocMipmappedArray(cudaMipmappedArray_t* mipmappedArray,
 {{if 'cudaGetMipmappedArrayLevel' in found_functions}}
 
 cdef cudaError_t cudaGetMipmappedArrayLevel(cudaArray_t* levelArray, cudaMipmappedArray_const_t mipmappedArray, unsigned int level) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMipmappedArrayGetLevel(<ccuda.CUarray*>levelArray, <ccuda.CUmipmappedArray>mipmappedArray, level)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGetMipmappedArrayLevel(levelArray, mipmappedArray, level)
 
 {{endif}}
 
@@ -1699,14 +1117,7 @@ cdef cudaError_t cudaMemcpy3DPeerAsync(const cudaMemcpy3DPeerParms* p, cudaStrea
 {{if 'cudaMemGetInfo' in found_functions}}
 
 cdef cudaError_t cudaMemGetInfo(size_t* free, size_t* total) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemGetInfo_v2(free, total)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemGetInfo(free, total)
 
 {{endif}}
 
@@ -1720,14 +1131,7 @@ cdef cudaError_t cudaArrayGetInfo(cudaChannelFormatDesc* desc, cudaExtent* exten
 {{if 'cudaArrayGetPlane' in found_functions}}
 
 cdef cudaError_t cudaArrayGetPlane(cudaArray_t* pPlaneArray, cudaArray_t hArray, unsigned int planeIdx) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuArrayGetPlane(<ccuda.CUarray*>pPlaneArray, <ccuda.CUarray>hArray, planeIdx)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaArrayGetPlane(pPlaneArray, hArray, planeIdx)
 
 {{endif}}
 
@@ -1839,28 +1243,14 @@ cdef cudaError_t cudaMemcpy2DFromArrayAsync(void* dst, size_t dpitch, cudaArray_
 {{if 'cudaMemset' in found_functions}}
 
 cdef cudaError_t cudaMemset(void* devPtr, int value, size_t count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemsetD8_v2(<ccuda.CUdeviceptr>devPtr, <unsigned char>value, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemset(devPtr, value, count)
 
 {{endif}}
 
 {{if 'cudaMemset2D' in found_functions}}
 
 cdef cudaError_t cudaMemset2D(void* devPtr, size_t pitch, int value, size_t width, size_t height) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemsetD2D8_v2(<ccuda.CUdeviceptr>devPtr, pitch, <unsigned char>value, width, height)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemset2D(devPtr, pitch, value, width, height)
 
 {{endif}}
 
@@ -1874,28 +1264,14 @@ cdef cudaError_t cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExten
 {{if 'cudaMemsetAsync' in found_functions}}
 
 cdef cudaError_t cudaMemsetAsync(void* devPtr, int value, size_t count, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemsetD8Async(<ccuda.CUdeviceptr>devPtr, <unsigned char>value, count, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemsetAsync(devPtr, value, count, stream)
 
 {{endif}}
 
 {{if 'cudaMemset2DAsync' in found_functions}}
 
 cdef cudaError_t cudaMemset2DAsync(void* devPtr, size_t pitch, int value, size_t width, size_t height, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemsetD2D8Async(<ccuda.CUdeviceptr>devPtr, pitch, <unsigned char>value, width, height, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemset2DAsync(devPtr, pitch, value, width, height, stream)
 
 {{endif}}
 
@@ -1909,14 +1285,7 @@ cdef cudaError_t cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cuda
 {{if 'cudaMemPrefetchAsync' in found_functions}}
 
 cdef cudaError_t cudaMemPrefetchAsync(const void* devPtr, size_t count, int dstDevice, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPrefetchAsync(<ccuda.CUdeviceptr>devPtr, count, <ccuda.CUdevice>dstDevice, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPrefetchAsync(devPtr, count, dstDevice, stream)
 
 {{endif}}
 
@@ -1979,70 +1348,35 @@ cdef cudaError_t cudaMemcpyFromArrayAsync(void* dst, cudaArray_const_t src, size
 {{if 'cudaMallocAsync' in found_functions}}
 
 cdef cudaError_t cudaMallocAsync(void** devPtr, size_t size, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemAllocAsync(<ccuda.CUdeviceptr*>devPtr, size, <ccuda.CUstream>hStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMallocAsync(devPtr, size, hStream)
 
 {{endif}}
 
 {{if 'cudaFreeAsync' in found_functions}}
 
 cdef cudaError_t cudaFreeAsync(void* devPtr, cudaStream_t hStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemFreeAsync(<ccuda.CUdeviceptr>devPtr, <ccuda.CUstream>hStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaFreeAsync(devPtr, hStream)
 
 {{endif}}
 
 {{if 'cudaMemPoolTrimTo' in found_functions}}
 
 cdef cudaError_t cudaMemPoolTrimTo(cudaMemPool_t memPool, size_t minBytesToKeep) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolTrimTo(<ccuda.CUmemoryPool>memPool, minBytesToKeep)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolTrimTo(memPool, minBytesToKeep)
 
 {{endif}}
 
 {{if 'cudaMemPoolSetAttribute' in found_functions}}
 
 cdef cudaError_t cudaMemPoolSetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolSetAttribute(<ccuda.CUmemoryPool>memPool, <ccuda.CUmemPool_attribute>attr, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolSetAttribute(memPool, attr, value)
 
 {{endif}}
 
 {{if 'cudaMemPoolGetAttribute' in found_functions}}
 
 cdef cudaError_t cudaMemPoolGetAttribute(cudaMemPool_t memPool, cudaMemPoolAttr attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolGetAttribute(<ccuda.CUmemoryPool>memPool, <ccuda.CUmemPool_attribute>attr, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolGetAttribute(memPool, attr, value)
 
 {{endif}}
 
@@ -2056,112 +1390,56 @@ cdef cudaError_t cudaMemPoolSetAccess(cudaMemPool_t memPool, const cudaMemAccess
 {{if 'cudaMemPoolGetAccess' in found_functions}}
 
 cdef cudaError_t cudaMemPoolGetAccess(cudaMemAccessFlags* flags, cudaMemPool_t memPool, cudaMemLocation* location) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolGetAccess(<ccuda.CUmemAccess_flags*>flags, <ccuda.CUmemoryPool>memPool, <ccuda.CUmemLocation*>location)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolGetAccess(flags, memPool, location)
 
 {{endif}}
 
 {{if 'cudaMemPoolCreate' in found_functions}}
 
 cdef cudaError_t cudaMemPoolCreate(cudaMemPool_t* memPool, const cudaMemPoolProps* poolProps) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolCreate(<ccuda.CUmemoryPool*>memPool, <ccuda.CUmemPoolProps*>poolProps)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolCreate(memPool, poolProps)
 
 {{endif}}
 
 {{if 'cudaMemPoolDestroy' in found_functions}}
 
 cdef cudaError_t cudaMemPoolDestroy(cudaMemPool_t memPool) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolDestroy(<ccuda.CUmemoryPool>memPool)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolDestroy(memPool)
 
 {{endif}}
 
 {{if 'cudaMallocFromPoolAsync' in found_functions}}
 
 cdef cudaError_t cudaMallocFromPoolAsync(void** ptr, size_t size, cudaMemPool_t memPool, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemAllocFromPoolAsync(<ccuda.CUdeviceptr*>ptr, size, <ccuda.CUmemoryPool>memPool, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMallocFromPoolAsync(ptr, size, memPool, stream)
 
 {{endif}}
 
 {{if 'cudaMemPoolExportToShareableHandle' in found_functions}}
 
 cdef cudaError_t cudaMemPoolExportToShareableHandle(void* shareableHandle, cudaMemPool_t memPool, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolExportToShareableHandle(shareableHandle, <ccuda.CUmemoryPool>memPool, <ccuda.CUmemAllocationHandleType>handleType, <unsigned long long>flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolExportToShareableHandle(shareableHandle, memPool, handleType, flags)
 
 {{endif}}
 
 {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}
 
 cdef cudaError_t cudaMemPoolImportFromShareableHandle(cudaMemPool_t* memPool, void* shareableHandle, cudaMemAllocationHandleType handleType, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolImportFromShareableHandle(<ccuda.CUmemoryPool*>memPool, shareableHandle, <ccuda.CUmemAllocationHandleType>handleType, <unsigned long long>flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolImportFromShareableHandle(memPool, shareableHandle, handleType, flags)
 
 {{endif}}
 
 {{if 'cudaMemPoolExportPointer' in found_functions}}
 
 cdef cudaError_t cudaMemPoolExportPointer(cudaMemPoolPtrExportData* exportData, void* ptr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolExportPointer(<ccuda.CUmemPoolPtrExportData*>exportData, <ccuda.CUdeviceptr>ptr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolExportPointer(exportData, ptr)
 
 {{endif}}
 
 {{if 'cudaMemPoolImportPointer' in found_functions}}
 
 cdef cudaError_t cudaMemPoolImportPointer(void** ptr, cudaMemPool_t memPool, cudaMemPoolPtrExportData* exportData) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuMemPoolImportPointer(<ccuda.CUdeviceptr*>ptr, <ccuda.CUmemoryPool>memPool, <ccuda.CUmemPoolPtrExportData*>exportData)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaMemPoolImportPointer(ptr, memPool, exportData)
 
 {{endif}}
 
@@ -2196,98 +1474,49 @@ cdef cudaError_t cudaDeviceDisablePeerAccess(int peerDevice) except ?cudaErrorCa
 {{if 'cudaGraphicsUnregisterResource' in found_functions}}
 
 cdef cudaError_t cudaGraphicsUnregisterResource(cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsUnregisterResource(<ccuda.CUgraphicsResource>resource)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsUnregisterResource(resource)
 
 {{endif}}
 
 {{if 'cudaGraphicsResourceSetMapFlags' in found_functions}}
 
 cdef cudaError_t cudaGraphicsResourceSetMapFlags(cudaGraphicsResource_t resource, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsResourceSetMapFlags_v2(<ccuda.CUgraphicsResource>resource, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsResourceSetMapFlags(resource, flags)
 
 {{endif}}
 
 {{if 'cudaGraphicsMapResources' in found_functions}}
 
 cdef cudaError_t cudaGraphicsMapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsMapResources(<unsigned int>count, <ccuda.CUgraphicsResource*>resources, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsMapResources(count, resources, stream)
 
 {{endif}}
 
 {{if 'cudaGraphicsUnmapResources' in found_functions}}
 
 cdef cudaError_t cudaGraphicsUnmapResources(int count, cudaGraphicsResource_t* resources, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsUnmapResources(<unsigned int>count, <ccuda.CUgraphicsResource*>resources, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsUnmapResources(count, resources, stream)
 
 {{endif}}
 
 {{if 'cudaGraphicsResourceGetMappedPointer' in found_functions}}
 
 cdef cudaError_t cudaGraphicsResourceGetMappedPointer(void** devPtr, size_t* size, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsResourceGetMappedPointer_v2(<ccuda.CUdeviceptr*>devPtr, size, <ccuda.CUgraphicsResource>resource)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsResourceGetMappedPointer(devPtr, size, resource)
 
 {{endif}}
 
 {{if 'cudaGraphicsSubResourceGetMappedArray' in found_functions}}
 
 cdef cudaError_t cudaGraphicsSubResourceGetMappedArray(cudaArray_t* array, cudaGraphicsResource_t resource, unsigned int arrayIndex, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsSubResourceGetMappedArray(<ccuda.CUarray*>array, <ccuda.CUgraphicsResource>resource, arrayIndex, mipLevel)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsSubResourceGetMappedArray(array, resource, arrayIndex, mipLevel)
 
 {{endif}}
 
 {{if 'cudaGraphicsResourceGetMappedMipmappedArray' in found_functions}}
 
 cdef cudaError_t cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray_t* mipmappedArray, cudaGraphicsResource_t resource) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsResourceGetMappedMipmappedArray(<ccuda.CUmipmappedArray*>mipmappedArray, <ccuda.CUgraphicsResource>resource)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray, resource)
 
 {{endif}}
 
@@ -2322,14 +1551,7 @@ cdef cudaError_t cudaCreateTextureObject_v2(cudaTextureObject_t* pTexObject, con
 {{if 'cudaDestroyTextureObject' in found_functions}}
 
 cdef cudaError_t cudaDestroyTextureObject(cudaTextureObject_t texObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuTexObjectDestroy(<ccuda.CUtexObject>texObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDestroyTextureObject(texObject)
 
 {{endif}}
 
@@ -2371,14 +1593,7 @@ cdef cudaError_t cudaCreateSurfaceObject(cudaSurfaceObject_t* pSurfObject, const
 {{if 'cudaDestroySurfaceObject' in found_functions}}
 
 cdef cudaError_t cudaDestroySurfaceObject(cudaSurfaceObject_t surfObject) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuSurfObjectDestroy(<ccuda.CUsurfObject>surfObject)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDestroySurfaceObject(surfObject)
 
 {{endif}}
 
@@ -2406,40 +1621,14 @@ cdef cudaError_t cudaRuntimeGetVersion(int* runtimeVersion) except ?cudaErrorCal
 {{if 'cudaGraphCreate' in found_functions}}
 
 cdef cudaError_t cudaGraphCreate(cudaGraph_t* pGraph, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphCreate(<ccuda.CUgraph*>pGraph, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphCreate(pGraph, flags)
 
 {{endif}}
 
 {{if 'cudaGraphAddKernelNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddKernelNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
-    _driver_pNodeParams.func = <ccuda.CUfunction>pNodeParams[0].func
-    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
-    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
-    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
-    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
-    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
-    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
-    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
-    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
-    _driver_pNodeParams.extra = pNodeParams[0].extra
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddKernelNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, &_driver_pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddKernelNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
 
 {{endif}}
 
@@ -2453,40 +1642,14 @@ cdef cudaError_t cudaGraphKernelNodeGetParams(cudaGraphNode_t node, cudaKernelNo
 {{if 'cudaGraphKernelNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphKernelNodeSetParams(cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
-    _driver_pNodeParams.func = <ccuda.CUfunction>pNodeParams[0].func
-    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
-    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
-    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
-    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
-    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
-    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
-    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
-    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
-    _driver_pNodeParams.extra = pNodeParams[0].extra
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphKernelNodeSetParams(<ccuda.CUgraphNode>node, &_driver_pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphKernelNodeSetParams(node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}
 
 cdef cudaError_t cudaGraphKernelNodeCopyAttributes(cudaGraphNode_t hSrc, cudaGraphNode_t hDst) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphKernelNodeCopyAttributes(<ccuda.CUgraphNode>hSrc, <ccuda.CUgraphNode>hDst)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphKernelNodeCopyAttributes(hSrc, hDst)
 
 {{endif}}
 
@@ -2549,280 +1712,140 @@ cdef cudaError_t cudaGraphAddMemsetNode(cudaGraphNode_t* pGraphNode, cudaGraph_t
 {{if 'cudaGraphMemsetNodeGetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphMemsetNodeGetParams(cudaGraphNode_t node, cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemsetNodeGetParams(<ccuda.CUgraphNode>node, <ccuda.CUDA_MEMSET_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphMemsetNodeGetParams(node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphMemsetNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphMemsetNodeSetParams(cudaGraphNode_t node, const cudaMemsetParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphMemsetNodeSetParams(<ccuda.CUgraphNode>node, <ccuda.CUDA_MEMSET_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphMemsetNodeSetParams(node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphAddHostNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddHostNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddHostNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUDA_HOST_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddHostNode(pGraphNode, graph, pDependencies, numDependencies, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphHostNodeGetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphHostNodeGetParams(cudaGraphNode_t node, cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphHostNodeGetParams(<ccuda.CUgraphNode>node, <ccuda.CUDA_HOST_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphHostNodeGetParams(node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphHostNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphHostNodeSetParams(cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphHostNodeSetParams(<ccuda.CUgraphNode>node, <ccuda.CUDA_HOST_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphHostNodeSetParams(node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphAddChildGraphNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddChildGraphNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddChildGraphNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUgraph>childGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddChildGraphNode(pGraphNode, graph, pDependencies, numDependencies, childGraph)
 
 {{endif}}
 
 {{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}
 
 cdef cudaError_t cudaGraphChildGraphNodeGetGraph(cudaGraphNode_t node, cudaGraph_t* pGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphChildGraphNodeGetGraph(<ccuda.CUgraphNode>node, <ccuda.CUgraph*>pGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphChildGraphNodeGetGraph(node, pGraph)
 
 {{endif}}
 
 {{if 'cudaGraphAddEmptyNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddEmptyNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddEmptyNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddEmptyNode(pGraphNode, graph, pDependencies, numDependencies)
 
 {{endif}}
 
 {{if 'cudaGraphAddEventRecordNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddEventRecordNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddEventRecordNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddEventRecordNode(pGraphNode, graph, pDependencies, numDependencies, event)
 
 {{endif}}
 
 {{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphEventRecordNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphEventRecordNodeGetEvent(<ccuda.CUgraphNode>node, <ccuda.CUevent*>event_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphEventRecordNodeGetEvent(node, event_out)
 
 {{endif}}
 
 {{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphEventRecordNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphEventRecordNodeSetEvent(<ccuda.CUgraphNode>node, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphEventRecordNodeSetEvent(node, event)
 
 {{endif}}
 
 {{if 'cudaGraphAddEventWaitNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddEventWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddEventWaitNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddEventWaitNode(pGraphNode, graph, pDependencies, numDependencies, event)
 
 {{endif}}
 
 {{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphEventWaitNodeGetEvent(cudaGraphNode_t node, cudaEvent_t* event_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphEventWaitNodeGetEvent(<ccuda.CUgraphNode>node, <ccuda.CUevent*>event_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphEventWaitNodeGetEvent(node, event_out)
 
 {{endif}}
 
 {{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphEventWaitNodeSetEvent(cudaGraphNode_t node, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphEventWaitNodeSetEvent(<ccuda.CUgraphNode>node, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphEventWaitNodeSetEvent(node, event)
 
 {{endif}}
 
 {{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddExternalSemaphoresSignalNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddExternalSemaphoresSignalNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddExternalSemaphoresSignalNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreSignalNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExternalSemaphoresSignalNodeGetParams(<ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>params_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExternalSemaphoresSignalNodeGetParams(hNode, params_out)
 
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExternalSemaphoresSignalNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExternalSemaphoresSignalNodeSetParams(<ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddExternalSemaphoresWaitNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddExternalSemaphoresWaitNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddExternalSemaphoresWaitNode(pGraphNode, graph, pDependencies, numDependencies, nodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeGetParams(cudaGraphNode_t hNode, cudaExternalSemaphoreWaitNodeParams* params_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExternalSemaphoresWaitNodeGetParams(<ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>params_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExternalSemaphoresWaitNodeGetParams(hNode, params_out)
 
 {{endif}}
 
 {{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExternalSemaphoresWaitNodeSetParams(cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExternalSemaphoresWaitNodeSetParams(<ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams)
 
 {{endif}}
 
@@ -2843,14 +1866,7 @@ cdef cudaError_t cudaGraphMemAllocNodeGetParams(cudaGraphNode_t node, cudaMemAll
 {{if 'cudaGraphAddMemFreeNode' in found_functions}}
 
 cdef cudaError_t cudaGraphAddMemFreeNode(cudaGraphNode_t* pGraphNode, cudaGraph_t graph, const cudaGraphNode_t* pDependencies, size_t numDependencies, void* dptr) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddMemFreeNode(<ccuda.CUgraphNode*>pGraphNode, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pDependencies, numDependencies, <ccuda.CUdeviceptr>dptr)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddMemFreeNode(pGraphNode, graph, pDependencies, numDependencies, dptr)
 
 {{endif}}
 
@@ -2864,250 +1880,119 @@ cdef cudaError_t cudaGraphMemFreeNodeGetParams(cudaGraphNode_t node, void* dptr_
 {{if 'cudaDeviceGraphMemTrim' in found_functions}}
 
 cdef cudaError_t cudaDeviceGraphMemTrim(int device) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGraphMemTrim(<ccuda.CUdevice>device)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGraphMemTrim(device)
 
 {{endif}}
 
 {{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}
 
 cdef cudaError_t cudaDeviceGetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceGetGraphMemAttribute(<ccuda.CUdevice>device, <ccuda.CUgraphMem_attribute>attr, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceGetGraphMemAttribute(device, attr, value)
 
 {{endif}}
 
 {{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}
 
 cdef cudaError_t cudaDeviceSetGraphMemAttribute(int device, cudaGraphMemAttributeType attr, void* value) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuDeviceSetGraphMemAttribute(<ccuda.CUdevice>device, <ccuda.CUgraphMem_attribute>attr, value)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaDeviceSetGraphMemAttribute(device, attr, value)
 
 {{endif}}
 
 {{if 'cudaGraphClone' in found_functions}}
 
 cdef cudaError_t cudaGraphClone(cudaGraph_t* pGraphClone, cudaGraph_t originalGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphClone(<ccuda.CUgraph*>pGraphClone, <ccuda.CUgraph>originalGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphClone(pGraphClone, originalGraph)
 
 {{endif}}
 
 {{if 'cudaGraphNodeFindInClone' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeFindInClone(cudaGraphNode_t* pNode, cudaGraphNode_t originalNode, cudaGraph_t clonedGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeFindInClone(<ccuda.CUgraphNode*>pNode, <ccuda.CUgraphNode>originalNode, <ccuda.CUgraph>clonedGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeFindInClone(pNode, originalNode, clonedGraph)
 
 {{endif}}
 
 {{if 'cudaGraphNodeGetType' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeGetType(cudaGraphNode_t node, cudaGraphNodeType* pType) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeGetType(<ccuda.CUgraphNode>node, <ccuda.CUgraphNodeType*>pType)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeGetType(node, pType)
 
 {{endif}}
 
 {{if 'cudaGraphGetNodes' in found_functions}}
 
 cdef cudaError_t cudaGraphGetNodes(cudaGraph_t graph, cudaGraphNode_t* nodes, size_t* numNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphGetNodes(<ccuda.CUgraph>graph, <ccuda.CUgraphNode*>nodes, numNodes)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphGetNodes(graph, nodes, numNodes)
 
 {{endif}}
 
 {{if 'cudaGraphGetRootNodes' in found_functions}}
 
 cdef cudaError_t cudaGraphGetRootNodes(cudaGraph_t graph, cudaGraphNode_t* pRootNodes, size_t* pNumRootNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphGetRootNodes(<ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pRootNodes, pNumRootNodes)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphGetRootNodes(graph, pRootNodes, pNumRootNodes)
 
 {{endif}}
 
 {{if 'cudaGraphGetEdges' in found_functions}}
 
 cdef cudaError_t cudaGraphGetEdges(cudaGraph_t graph, cudaGraphNode_t* from_, cudaGraphNode_t* to, size_t* numEdges) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphGetEdges(<ccuda.CUgraph>graph, <ccuda.CUgraphNode*>from_, <ccuda.CUgraphNode*>to, numEdges)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphGetEdges(graph, from_, to, numEdges)
 
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependencies' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeGetDependencies(cudaGraphNode_t node, cudaGraphNode_t* pDependencies, size_t* pNumDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeGetDependencies(<ccuda.CUgraphNode>node, <ccuda.CUgraphNode*>pDependencies, pNumDependencies)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeGetDependencies(node, pDependencies, pNumDependencies)
 
 {{endif}}
 
 {{if 'cudaGraphNodeGetDependentNodes' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeGetDependentNodes(cudaGraphNode_t node, cudaGraphNode_t* pDependentNodes, size_t* pNumDependentNodes) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeGetDependentNodes(<ccuda.CUgraphNode>node, <ccuda.CUgraphNode*>pDependentNodes, pNumDependentNodes)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeGetDependentNodes(node, pDependentNodes, pNumDependentNodes)
 
 {{endif}}
 
 {{if 'cudaGraphAddDependencies' in found_functions}}
 
 cdef cudaError_t cudaGraphAddDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphAddDependencies(<ccuda.CUgraph>graph, <ccuda.CUgraphNode*>from_, <ccuda.CUgraphNode*>to, numDependencies)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphAddDependencies(graph, from_, to, numDependencies)
 
 {{endif}}
 
 {{if 'cudaGraphRemoveDependencies' in found_functions}}
 
 cdef cudaError_t cudaGraphRemoveDependencies(cudaGraph_t graph, const cudaGraphNode_t* from_, const cudaGraphNode_t* to, size_t numDependencies) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphRemoveDependencies(<ccuda.CUgraph>graph, <ccuda.CUgraphNode*>from_, <ccuda.CUgraphNode*>to, numDependencies)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphRemoveDependencies(graph, from_, to, numDependencies)
 
 {{endif}}
 
 {{if 'cudaGraphDestroyNode' in found_functions}}
 
 cdef cudaError_t cudaGraphDestroyNode(cudaGraphNode_t node) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphDestroyNode(<ccuda.CUgraphNode>node)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphDestroyNode(node)
 
 {{endif}}
 
 {{if 'cudaGraphInstantiate' in found_functions}}
 
 cdef cudaError_t cudaGraphInstantiate(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, cudaGraphNode_t* pErrorNode, char* pLogBuffer, size_t bufferSize) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphInstantiate_v2(<ccuda.CUgraphExec*>pGraphExec, <ccuda.CUgraph>graph, <ccuda.CUgraphNode*>pErrorNode, pLogBuffer, bufferSize)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphInstantiate(pGraphExec, graph, pErrorNode, pLogBuffer, bufferSize)
 
 {{endif}}
 
 {{if 'cudaGraphInstantiateWithFlags' in found_functions}}
 
 cdef cudaError_t cudaGraphInstantiateWithFlags(cudaGraphExec_t* pGraphExec, cudaGraph_t graph, unsigned long long flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphInstantiateWithFlags(<ccuda.CUgraphExec*>pGraphExec, <ccuda.CUgraph>graph, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphInstantiateWithFlags(pGraphExec, graph, flags)
 
 {{endif}}
 
 {{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExecKernelNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaKernelNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS _driver_pNodeParams
-    _driver_pNodeParams.func = <ccuda.CUfunction>pNodeParams[0].func
-    _driver_pNodeParams.gridDimX = pNodeParams[0].gridDim.x
-    _driver_pNodeParams.gridDimY = pNodeParams[0].gridDim.y
-    _driver_pNodeParams.gridDimZ = pNodeParams[0].gridDim.z
-    _driver_pNodeParams.blockDimX = pNodeParams[0].blockDim.x
-    _driver_pNodeParams.blockDimY = pNodeParams[0].blockDim.y
-    _driver_pNodeParams.blockDimZ = pNodeParams[0].blockDim.z
-    _driver_pNodeParams.sharedMemBytes = pNodeParams[0].sharedMemBytes
-    _driver_pNodeParams.kernelParams = pNodeParams[0].kernelParams
-    _driver_pNodeParams.extra = pNodeParams[0].extra
-
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecKernelNodeSetParams(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>node, &_driver_pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams)
 
 {{endif}}
 
@@ -3135,266 +2020,133 @@ cdef cudaError_t cudaGraphExecMemsetNodeSetParams(cudaGraphExec_t hGraphExec, cu
 {{if 'cudaGraphExecHostNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExecHostNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, const cudaHostNodeParams* pNodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecHostNodeSetParams(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>node, <ccuda.CUDA_HOST_NODE_PARAMS*>pNodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExecChildGraphNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t node, cudaGraph_t childGraph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecChildGraphNodeSetParams(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>node, <ccuda.CUgraph>childGraph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph)
 
 {{endif}}
 
 {{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphExecEventRecordNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecEventRecordNodeSetEvent(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event)
 
 {{endif}}
 
 {{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}
 
 cdef cudaError_t cudaGraphExecEventWaitNodeSetEvent(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, cudaEvent_t event) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecEventWaitNodeSetEvent(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, <ccuda.CUevent>event)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event)
 
 {{endif}}
 
 {{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExecExternalSemaphoresSignalNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreSignalNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecExternalSemaphoresSignalNodeSetParams(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
 
 cdef cudaError_t cudaGraphExecExternalSemaphoresWaitNodeSetParams(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, const cudaExternalSemaphoreWaitNodeParams* nodeParams) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecExternalSemaphoresWaitNodeSetParams(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, <ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>nodeParams)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams)
 
 {{endif}}
 
 {{if 'cudaGraphNodeSetEnabled' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeSetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeSetEnabled(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, isEnabled)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeSetEnabled(hGraphExec, hNode, isEnabled)
 
 {{endif}}
 
 {{if 'cudaGraphNodeGetEnabled' in found_functions}}
 
 cdef cudaError_t cudaGraphNodeGetEnabled(cudaGraphExec_t hGraphExec, cudaGraphNode_t hNode, unsigned int* isEnabled) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphNodeGetEnabled(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraphNode>hNode, isEnabled)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphNodeGetEnabled(hGraphExec, hNode, isEnabled)
 
 {{endif}}
 
 {{if 'cudaGraphExecUpdate' in found_functions}}
 
 cdef cudaError_t cudaGraphExecUpdate(cudaGraphExec_t hGraphExec, cudaGraph_t hGraph, cudaGraphNode_t* hErrorNode_out, cudaGraphExecUpdateResult* updateResult_out) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecUpdate(<ccuda.CUgraphExec>hGraphExec, <ccuda.CUgraph>hGraph, <ccuda.CUgraphNode*>hErrorNode_out, <ccuda.CUgraphExecUpdateResult*>updateResult_out)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecUpdate(hGraphExec, hGraph, hErrorNode_out, updateResult_out)
 
 {{endif}}
 
 {{if 'cudaGraphUpload' in found_functions}}
 
 cdef cudaError_t cudaGraphUpload(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphUpload(<ccuda.CUgraphExec>graphExec, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphUpload(graphExec, stream)
 
 {{endif}}
 
 {{if 'cudaGraphLaunch' in found_functions}}
 
 cdef cudaError_t cudaGraphLaunch(cudaGraphExec_t graphExec, cudaStream_t stream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphLaunch(<ccuda.CUgraphExec>graphExec, <ccuda.CUstream>stream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphLaunch(graphExec, stream)
 
 {{endif}}
 
 {{if 'cudaGraphExecDestroy' in found_functions}}
 
 cdef cudaError_t cudaGraphExecDestroy(cudaGraphExec_t graphExec) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphExecDestroy(<ccuda.CUgraphExec>graphExec)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphExecDestroy(graphExec)
 
 {{endif}}
 
 {{if 'cudaGraphDestroy' in found_functions}}
 
 cdef cudaError_t cudaGraphDestroy(cudaGraph_t graph) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphDestroy(<ccuda.CUgraph>graph)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphDestroy(graph)
 
 {{endif}}
 
 {{if 'cudaGraphDebugDotPrint' in found_functions}}
 
 cdef cudaError_t cudaGraphDebugDotPrint(cudaGraph_t graph, const char* path, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphDebugDotPrint(<ccuda.CUgraph>graph, path, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphDebugDotPrint(graph, path, flags)
 
 {{endif}}
 
 {{if 'cudaUserObjectCreate' in found_functions}}
 
 cdef cudaError_t cudaUserObjectCreate(cudaUserObject_t* object_out, void* ptr, cudaHostFn_t destroy, unsigned int initialRefcount, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuUserObjectCreate(<ccuda.CUuserObject*>object_out, ptr, <ccuda.CUhostFn>destroy, initialRefcount, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaUserObjectCreate(object_out, ptr, destroy, initialRefcount, flags)
 
 {{endif}}
 
 {{if 'cudaUserObjectRetain' in found_functions}}
 
 cdef cudaError_t cudaUserObjectRetain(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuUserObjectRetain(<ccuda.CUuserObject>object, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaUserObjectRetain(object, count)
 
 {{endif}}
 
 {{if 'cudaUserObjectRelease' in found_functions}}
 
 cdef cudaError_t cudaUserObjectRelease(cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuUserObjectRelease(<ccuda.CUuserObject>object, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaUserObjectRelease(object, count)
 
 {{endif}}
 
 {{if 'cudaGraphRetainUserObject' in found_functions}}
 
 cdef cudaError_t cudaGraphRetainUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphRetainUserObject(<ccuda.CUgraph>graph, <ccuda.CUuserObject>object, count, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphRetainUserObject(graph, object, count, flags)
 
 {{endif}}
 
 {{if 'cudaGraphReleaseUserObject' in found_functions}}
 
 cdef cudaError_t cudaGraphReleaseUserObject(cudaGraph_t graph, cudaUserObject_t object, unsigned int count) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphReleaseUserObject(<ccuda.CUgraph>graph, <ccuda.CUuserObject>object, count)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGraphReleaseUserObject(graph, object, count)
 
 {{endif}}
 
@@ -3408,14 +2160,7 @@ cdef cudaError_t cudaGetDriverEntryPoint(const char* symbol, void** funcPtr, uns
 {{if 'cudaGetExportTable' in found_functions}}
 
 cdef cudaError_t cudaGetExportTable(const void** ppExportTable, const cudaUUID_t* pExportTableId) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGetExportTable(ppExportTable, <ccuda.CUuuid*>pExportTableId)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaGetExportTable(ppExportTable, pExportTableId)
 
 {{endif}}
 
@@ -3440,185 +2185,157 @@ cdef cudaExtent make_cudaExtent(size_t w, size_t h, size_t d) nogil:
 
 {{endif}}
 
-{{if True or 'cudaProfilerInitialize' in found_functions}}
-
-cdef cudaError_t cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil:
-    return _cudaProfilerInitialize(configFile, outputFile, outputMode)
-
-{{endif}}
-
-{{if True or 'cudaProfilerStart' in found_functions}}
-
-cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuProfilerStart()
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaProfilerStop' in found_functions}}
-
-cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuProfilerStop()
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
-
-{{endif}}
-
-{{if True or 'cudaGraphicsEGLRegisterImage' in found_functions}}
+{{if True}}
 
-cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource_t* pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuGraphicsEGLRegisterImage(<ccuda.CUgraphicsResource*>pCudaResource, image, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+cdef cudaError_t cudaGraphicsEGLRegisterImage(cudaGraphicsResource** pCudaResource, EGLImageKHR image, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGraphicsEGLRegisterImage(pCudaResource, image, flags)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerConnect' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamConsumerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamConsumerConnect(<ccuda.CUeglStreamConnection*>conn, eglStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamConsumerConnect(conn, eglStream)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamConsumerConnectWithFlags(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamConsumerConnectWithFlags(<ccuda.CUeglStreamConnection*>conn, eglStream, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamConsumerConnectWithFlags(conn, eglStream, flags)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamConsumerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamConsumerDisconnect(<ccuda.CUeglStreamConnection*>conn)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamConsumerDisconnect(conn)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamConsumerAcquireFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t* pCudaResource, cudaStream_t* pStream, unsigned int timeout) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamConsumerAcquireFrame(<ccuda.CUeglStreamConnection*>conn, <ccuda.CUgraphicsResource*>pCudaResource, <ccuda.CUstream*>pStream, timeout)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, timeout)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamConsumerReleaseFrame(cudaEglStreamConnection* conn, cudaGraphicsResource_t pCudaResource, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamConsumerReleaseFrame(<ccuda.CUeglStreamConnection*>conn, <ccuda.CUgraphicsResource>pCudaResource, <ccuda.CUstream*>pStream)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamProducerConnect(cudaEglStreamConnection* conn, EGLStreamKHR eglStream, EGLint width, EGLint height) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamProducerConnect(<ccuda.CUeglStreamConnection*>conn, eglStream, width, height)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamProducerConnect(conn, eglStream, width, height)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamProducerDisconnect(cudaEglStreamConnection* conn) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEGLStreamProducerDisconnect(<ccuda.CUeglStreamConnection*>conn)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEGLStreamProducerDisconnect(conn)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamProducerPresentFrame(cudaEglStreamConnection* conn, cudaEglFrame eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
     return _cudaEGLStreamProducerPresentFrame(conn, eglframe, pStream)
 
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEGLStreamProducerReturnFrame(cudaEglStreamConnection* conn, cudaEglFrame* eglframe, cudaStream_t* pStream) except ?cudaErrorCallRequiresNewerDriver nogil:
     return _cudaEGLStreamProducerReturnFrame(conn, eglframe, pStream)
 
 {{endif}}
 
-{{if True or 'cudaGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaGraphicsResourceGetMappedEglFrame(cudaEglFrame* eglFrame, cudaGraphicsResource_t resource, unsigned int index, unsigned int mipLevel) except ?cudaErrorCallRequiresNewerDriver nogil:
     return _cudaGraphicsResourceGetMappedEglFrame(eglFrame, resource, index, mipLevel)
 
 {{endif}}
 
-{{if True or 'cudaEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 cdef cudaError_t cudaEventCreateFromEGLSync(cudaEvent_t* phEvent, EGLSyncKHR eglSync, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
-    cdef cudaError_t err
-    err = m_global.lazyInitContextState()
-    if err != cudaSuccess:
-        return err
-    err = <cudaError_t>ccuda._cuEventCreateFromEGLSync(<ccuda.CUevent*>phEvent, eglSync, flags)
-    if err != cudaSuccess:
-        _setLastError(err)
-    return err
+    return _cudaEventCreateFromEGLSync(phEvent, eglSync, flags)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaProfilerInitialize(const char* configFile, const char* outputFile, cudaOutputMode_t outputMode) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaProfilerInitialize(configFile, outputFile, outputMode)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaProfilerStart() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaProfilerStart()
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaProfilerStop() except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaProfilerStop()
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaGLGetDevices(unsigned int* pCudaDeviceCount, int* pCudaDevices, unsigned int cudaDeviceCount, cudaGLDeviceList deviceList) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGLGetDevices(pCudaDeviceCount, pCudaDevices, cudaDeviceCount, deviceList)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaGraphicsGLRegisterImage(cudaGraphicsResource** resource, GLuint image, GLenum target, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGraphicsGLRegisterImage(resource, image, target, flags)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaGraphicsGLRegisterBuffer(cudaGraphicsResource** resource, GLuint buffer, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGraphicsGLRegisterBuffer(resource, buffer, flags)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaVDPAUGetDevice(int* device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaVDPAUGetDevice(device, vdpDevice, vdpGetProcAddress)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaVDPAUSetVDPAUDevice(int device, VdpDevice vdpDevice, VdpGetProcAddress* vdpGetProcAddress) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaVDPAUSetVDPAUDevice(device, vdpDevice, vdpGetProcAddress)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaGraphicsVDPAURegisterVideoSurface(cudaGraphicsResource** resource, VdpVideoSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGraphicsVDPAURegisterVideoSurface(resource, vdpSurface, flags)
+
+{{endif}}
+
+{{if True}}
+
+cdef cudaError_t cudaGraphicsVDPAURegisterOutputSurface(cudaGraphicsResource** resource, VdpOutputSurface vdpSurface, unsigned int flags) except ?cudaErrorCallRequiresNewerDriver nogil:
+    return _cudaGraphicsVDPAURegisterOutputSurface(resource, vdpSurface, flags)
 
 {{endif}}
 
diff --git a/cuda/cuda.pxd.in b/cuda/cuda/bindings/driver.pxd.in
similarity index 76%
rename from cuda/cuda.pxd.in
rename to cuda/cuda/bindings/driver.pxd.in
index c7e8fb6d..dc033110 100644
--- a/cuda/cuda.pxd.in
+++ b/cuda/cuda/bindings/driver.pxd.in
@@ -1,12 +1,12 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda.ccuda as ccuda
-cimport cuda._lib.utils as utils
+cimport cuda.bindings.cydriver as cydriver
+cimport cuda.bindings._lib.utils as utils
 
 {{if 'CUcontext' in found_types}}
 
@@ -21,8 +21,8 @@ cdef class CUcontext:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUcontext  __val
-    cdef ccuda.CUcontext* _ptr
+    cdef cydriver.CUcontext  __val
+    cdef cydriver.CUcontext* _ptr
 {{endif}}
 
 {{if 'CUmodule' in found_types}}
@@ -38,8 +38,8 @@ cdef class CUmodule:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmodule  __val
-    cdef ccuda.CUmodule* _ptr
+    cdef cydriver.CUmodule  __val
+    cdef cydriver.CUmodule* _ptr
 {{endif}}
 
 {{if 'CUfunction' in found_types}}
@@ -55,8 +55,8 @@ cdef class CUfunction:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUfunction  __val
-    cdef ccuda.CUfunction* _ptr
+    cdef cydriver.CUfunction  __val
+    cdef cydriver.CUfunction* _ptr
 {{endif}}
 
 {{if 'CUarray' in found_types}}
@@ -72,8 +72,8 @@ cdef class CUarray:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarray  __val
-    cdef ccuda.CUarray* _ptr
+    cdef cydriver.CUarray  __val
+    cdef cydriver.CUarray* _ptr
 {{endif}}
 
 {{if 'CUmipmappedArray' in found_types}}
@@ -89,8 +89,8 @@ cdef class CUmipmappedArray:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmipmappedArray  __val
-    cdef ccuda.CUmipmappedArray* _ptr
+    cdef cydriver.CUmipmappedArray  __val
+    cdef cydriver.CUmipmappedArray* _ptr
 {{endif}}
 
 {{if 'CUtexref' in found_types}}
@@ -106,8 +106,8 @@ cdef class CUtexref:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUtexref  __val
-    cdef ccuda.CUtexref* _ptr
+    cdef cydriver.CUtexref  __val
+    cdef cydriver.CUtexref* _ptr
 {{endif}}
 
 {{if 'CUsurfref' in found_types}}
@@ -123,8 +123,8 @@ cdef class CUsurfref:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUsurfref  __val
-    cdef ccuda.CUsurfref* _ptr
+    cdef cydriver.CUsurfref  __val
+    cdef cydriver.CUsurfref* _ptr
 {{endif}}
 
 {{if 'CUevent' in found_types}}
@@ -140,8 +140,8 @@ cdef class CUevent:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUevent  __val
-    cdef ccuda.CUevent* _ptr
+    cdef cydriver.CUevent  __val
+    cdef cydriver.CUevent* _ptr
 {{endif}}
 
 {{if 'CUstream' in found_types}}
@@ -157,8 +157,8 @@ cdef class CUstream:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstream  __val
-    cdef ccuda.CUstream* _ptr
+    cdef cydriver.CUstream  __val
+    cdef cydriver.CUstream* _ptr
 {{endif}}
 
 {{if 'CUgraphicsResource' in found_types}}
@@ -174,8 +174,8 @@ cdef class CUgraphicsResource:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUgraphicsResource  __val
-    cdef ccuda.CUgraphicsResource* _ptr
+    cdef cydriver.CUgraphicsResource  __val
+    cdef cydriver.CUgraphicsResource* _ptr
 {{endif}}
 
 {{if 'CUexternalMemory' in found_types}}
@@ -191,8 +191,8 @@ cdef class CUexternalMemory:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUexternalMemory  __val
-    cdef ccuda.CUexternalMemory* _ptr
+    cdef cydriver.CUexternalMemory  __val
+    cdef cydriver.CUexternalMemory* _ptr
 {{endif}}
 
 {{if 'CUexternalSemaphore' in found_types}}
@@ -208,8 +208,8 @@ cdef class CUexternalSemaphore:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUexternalSemaphore  __val
-    cdef ccuda.CUexternalSemaphore* _ptr
+    cdef cydriver.CUexternalSemaphore  __val
+    cdef cydriver.CUexternalSemaphore* _ptr
 {{endif}}
 
 {{if 'CUgraph' in found_types}}
@@ -225,8 +225,8 @@ cdef class CUgraph:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUgraph  __val
-    cdef ccuda.CUgraph* _ptr
+    cdef cydriver.CUgraph  __val
+    cdef cydriver.CUgraph* _ptr
 {{endif}}
 
 {{if 'CUgraphNode' in found_types}}
@@ -242,8 +242,8 @@ cdef class CUgraphNode:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUgraphNode  __val
-    cdef ccuda.CUgraphNode* _ptr
+    cdef cydriver.CUgraphNode  __val
+    cdef cydriver.CUgraphNode* _ptr
 {{endif}}
 
 {{if 'CUgraphExec' in found_types}}
@@ -259,8 +259,8 @@ cdef class CUgraphExec:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUgraphExec  __val
-    cdef ccuda.CUgraphExec* _ptr
+    cdef cydriver.CUgraphExec  __val
+    cdef cydriver.CUgraphExec* _ptr
 {{endif}}
 
 {{if 'CUmemoryPool' in found_types}}
@@ -276,8 +276,8 @@ cdef class CUmemoryPool:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemoryPool  __val
-    cdef ccuda.CUmemoryPool* _ptr
+    cdef cydriver.CUmemoryPool  __val
+    cdef cydriver.CUmemoryPool* _ptr
 {{endif}}
 
 {{if 'CUuserObject' in found_types}}
@@ -293,8 +293,8 @@ cdef class CUuserObject:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUuserObject  __val
-    cdef ccuda.CUuserObject* _ptr
+    cdef cydriver.CUuserObject  __val
+    cdef cydriver.CUuserObject* _ptr
 {{endif}}
 
 {{if 'CUlinkState' in found_types}}
@@ -308,29 +308,31 @@ cdef class CUlinkState:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUlinkState  __val
-    cdef ccuda.CUlinkState* _ptr
+    cdef cydriver.CUlinkState  __val
+    cdef cydriver.CUlinkState* _ptr
     cdef list _keepalive
 {{endif}}
 
-{{if True or 'EGLImageKHR' in found_types}}
+{{if True}}
 
-cdef class EGLImageKHR:
+cdef class CUeglStreamConnection:
     """
 
+    CUDA EGLSream Connection
+
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccuda.EGLImageKHR  __val
-    cdef ccuda.EGLImageKHR* _ptr
+    cdef cydriver.CUeglStreamConnection  __val
+    cdef cydriver.CUeglStreamConnection* _ptr
 {{endif}}
 
-{{if True or 'EGLStreamKHR' in found_types}}
+{{if True}}
 
-cdef class EGLStreamKHR:
+cdef class EGLImageKHR:
     """
 
     Methods
@@ -339,13 +341,13 @@ cdef class EGLStreamKHR:
         Get memory address of class instance
 
     """
-    cdef ccuda.EGLStreamKHR  __val
-    cdef ccuda.EGLStreamKHR* _ptr
+    cdef cydriver.EGLImageKHR  __val
+    cdef cydriver.EGLImageKHR* _ptr
 {{endif}}
 
-{{if True or 'EGLSyncKHR' in found_types}}
+{{if True}}
 
-cdef class EGLSyncKHR:
+cdef class EGLStreamKHR:
     """
 
     Methods
@@ -354,25 +356,23 @@ cdef class EGLSyncKHR:
         Get memory address of class instance
 
     """
-    cdef ccuda.EGLSyncKHR  __val
-    cdef ccuda.EGLSyncKHR* _ptr
+    cdef cydriver.EGLStreamKHR  __val
+    cdef cydriver.EGLStreamKHR* _ptr
 {{endif}}
 
-{{if True or 'CUeglStreamConnection' in found_types}}
+{{if True}}
 
-cdef class CUeglStreamConnection:
+cdef class EGLSyncKHR:
     """
 
-    CUDA EGLSream Connection
-
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccuda.CUeglStreamConnection  __val
-    cdef ccuda.CUeglStreamConnection* _ptr
+    cdef cydriver.EGLSyncKHR  __val
+    cdef cydriver.EGLSyncKHR* _ptr
 {{endif}}
 
 {{if 'CUhostFn' in found_types}}
@@ -386,8 +386,8 @@ cdef class CUhostFn:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUhostFn  __val
-    cdef ccuda.CUhostFn* _ptr
+    cdef cydriver.CUhostFn  __val
+    cdef cydriver.CUhostFn* _ptr
 {{endif}}
 
 {{if 'CUstreamCallback' in found_types}}
@@ -401,8 +401,8 @@ cdef class CUstreamCallback:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstreamCallback  __val
-    cdef ccuda.CUstreamCallback* _ptr
+    cdef cydriver.CUstreamCallback  __val
+    cdef cydriver.CUstreamCallback* _ptr
 {{endif}}
 
 {{if 'CUoccupancyB2DSize' in found_types}}
@@ -416,15 +416,14 @@ cdef class CUoccupancyB2DSize:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUoccupancyB2DSize  __val
-    cdef ccuda.CUoccupancyB2DSize* _ptr
+    cdef cydriver.CUoccupancyB2DSize  __val
+    cdef cydriver.CUoccupancyB2DSize* _ptr
 {{endif}}
 
-{{if 'CUuuid_st' in found_types}}
+{{if 'struct CUuuid_st' in found_types}}
 
 cdef class CUuuid_st:
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -436,10 +435,10 @@ cdef class CUuuid_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUuuid_st  __val
-    cdef ccuda.CUuuid_st* _ptr
+    cdef cydriver.CUuuid_st __val
+    cdef cydriver.CUuuid_st* _ptr
 {{endif}}
-{{if 'CUipcEventHandle_st' in found_types}}
+{{if 'struct CUipcEventHandle_st' in found_types}}
 
 cdef class CUipcEventHandle_st:
     """
@@ -456,10 +455,10 @@ cdef class CUipcEventHandle_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUipcEventHandle_st  __val
-    cdef ccuda.CUipcEventHandle_st* _ptr
+    cdef cydriver.CUipcEventHandle_st __val
+    cdef cydriver.CUipcEventHandle_st* _ptr
 {{endif}}
-{{if 'CUipcMemHandle_st' in found_types}}
+{{if 'struct CUipcMemHandle_st' in found_types}}
 
 cdef class CUipcMemHandle_st:
     """
@@ -476,20 +475,21 @@ cdef class CUipcMemHandle_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUipcMemHandle_st  __val
-    cdef ccuda.CUipcMemHandle_st* _ptr
+    cdef cydriver.CUipcMemHandle_st __val
+    cdef cydriver.CUipcMemHandle_st* _ptr
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpWaitValueParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
 
     address : CUdeviceptr
 
+    value : cuuint32_t
+
     value64 : cuuint64_t
 
     flags : unsigned int
@@ -503,22 +503,24 @@ cdef class CUstreamMemOpWaitValueParams_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstreamBatchMemOpParams_union* _ptr
+    cdef cydriver.CUstreamBatchMemOpParams_union* _ptr
     cdef CUdeviceptr _address
+    cdef cuuint32_t _value
     cdef cuuint64_t _value64
     cdef CUdeviceptr _alias
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpWriteValueParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
 
     address : CUdeviceptr
 
+    value : cuuint32_t
+
     value64 : cuuint64_t
 
     flags : unsigned int
@@ -532,16 +534,16 @@ cdef class CUstreamMemOpWriteValueParams_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstreamBatchMemOpParams_union* _ptr
+    cdef cydriver.CUstreamBatchMemOpParams_union* _ptr
     cdef CUdeviceptr _address
+    cdef cuuint32_t _value
     cdef cuuint64_t _value64
     cdef CUdeviceptr _alias
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpFlushRemoteWritesParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
@@ -555,13 +557,12 @@ cdef class CUstreamMemOpFlushRemoteWritesParams_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstreamBatchMemOpParams_union* _ptr
+    cdef cydriver.CUstreamBatchMemOpParams_union* _ptr
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpMemoryBarrierParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
@@ -575,7 +576,7 @@ cdef class CUstreamMemOpMemoryBarrierParams_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUstreamBatchMemOpParams_union* _ptr
+    cdef cydriver.CUstreamBatchMemOpParams_union* _ptr
 {{endif}}
 {{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
@@ -604,19 +605,17 @@ cdef class CUstreamBatchMemOpParams_union:
         Get memory address of class instance
 
     """
-
-    cdef ccuda.CUstreamBatchMemOpParams_union __val
-    cdef ccuda.CUstreamBatchMemOpParams_union* _ptr
-    {{if 'waitValue' in found_unions['CUstreamBatchMemOpParams_union']['members']}}cdef CUstreamMemOpWaitValueParams_st _waitValue{{endif}}
-    {{if 'writeValue' in found_unions['CUstreamBatchMemOpParams_union']['members']}}cdef CUstreamMemOpWriteValueParams_st _writeValue{{endif}}
-    {{if 'flushRemoteWrites' in found_unions['CUstreamBatchMemOpParams_union']['members']}}cdef CUstreamMemOpFlushRemoteWritesParams_st _flushRemoteWrites{{endif}}
-    {{if 'memoryBarrier' in found_unions['CUstreamBatchMemOpParams_union']['members']}}cdef CUstreamMemOpMemoryBarrierParams_st _memoryBarrier{{endif}}
+    cdef cydriver.CUstreamBatchMemOpParams_union __val
+    cdef cydriver.CUstreamBatchMemOpParams_union* _ptr
+    cdef CUstreamMemOpWaitValueParams_st _waitValue
+    cdef CUstreamMemOpWriteValueParams_st _writeValue
+    cdef CUstreamMemOpFlushRemoteWritesParams_st _flushRemoteWrites
+    cdef CUstreamMemOpMemoryBarrierParams_st _memoryBarrier
 {{endif}}
-{{if 'CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
     """
-
     Attributes
     ----------
     ctx : CUcontext
@@ -634,13 +633,14 @@ cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS_st* _ptr
     cdef CUcontext _ctx
     cdef size_t _paramArray_length
-    cdef ccuda.CUstreamBatchMemOpParams* _paramArray
+    cdef cydriver.CUstreamBatchMemOpParams* _paramArray
+
 {{endif}}
-{{if 'CUdevprop_st' in found_types}}
+{{if 'struct CUdevprop_st' in found_types}}
 
 cdef class CUdevprop_st:
     """
@@ -675,10 +675,10 @@ cdef class CUdevprop_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUdevprop_st  __val
-    cdef ccuda.CUdevprop_st* _ptr
+    cdef cydriver.CUdevprop_st __val
+    cdef cydriver.CUdevprop_st* _ptr
 {{endif}}
-{{if 'CUaccessPolicyWindow_st' in found_types}}
+{{if 'struct CUaccessPolicyWindow_st' in found_types}}
 
 cdef class CUaccessPolicyWindow_st:
     """
@@ -715,11 +715,10 @@ cdef class CUaccessPolicyWindow_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUaccessPolicyWindow_st  __val
-    cdef ccuda.CUaccessPolicyWindow_st* _ptr
-    cdef utils.HelperInputVoidPtr _cbase_ptr
+    cdef cydriver.CUaccessPolicyWindow_st __val
+    cdef cydriver.CUaccessPolicyWindow_st* _ptr
 {{endif}}
-{{if 'CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_KERNEL_NODE_PARAMS_st:
     """
@@ -754,12 +753,12 @@ cdef class CUDA_KERNEL_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS_st* _ptr
     cdef CUfunction _func
-    cdef utils.HelperKernelParams _ckernelParams
+    cdef utils.HelperKernelParams _cykernelParams
 {{endif}}
-{{if 'CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_MEMSET_NODE_PARAMS_st:
     """
@@ -786,11 +785,11 @@ cdef class CUDA_MEMSET_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS_st* _ptr
     cdef CUdeviceptr _dst
 {{endif}}
-{{if 'CUDA_HOST_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_HOST_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_HOST_NODE_PARAMS_st:
     """
@@ -809,16 +808,14 @@ cdef class CUDA_HOST_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_HOST_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_HOST_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_HOST_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_HOST_NODE_PARAMS_st* _ptr
     cdef CUhostFn _fn
-    cdef utils.HelperInputVoidPtr _cuserData
 {{endif}}
-{{if 'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s' in found_types}}
+{{if 'union CUlaunchAttributeValue_union' in found_types}}
 
-cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s:
+cdef class anon_struct0:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -834,13 +831,12 @@ cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue
         Get memory address of class instance
 
     """
-    cdef ccuda.CUlaunchAttributeValue_union* _ptr
+    cdef cydriver.CUlaunchAttributeValue_union* _ptr
 {{endif}}
-{{if 'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s' in found_types}}
+{{if 'union CUlaunchAttributeValue_union' in found_types}}
 
-cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s:
+cdef class anon_struct1:
     """
-
     Attributes
     ----------
     event : CUevent
@@ -856,14 +852,13 @@ cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue
         Get memory address of class instance
 
     """
-    cdef ccuda.CUlaunchAttributeValue_union* _ptr
+    cdef cydriver.CUlaunchAttributeValue_union* _ptr
     cdef CUevent _event
 {{endif}}
 {{if 'union CUlaunchAttributeValue_union' in found_types}}
 
 cdef class CUlaunchAttributeValue_union:
     """
-
     Attributes
     ----------
     pad : bytes
@@ -874,13 +869,13 @@ cdef class CUlaunchAttributeValue_union:
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -891,18 +886,16 @@ cdef class CUlaunchAttributeValue_union:
         Get memory address of class instance
 
     """
-
-    cdef ccuda.CUlaunchAttributeValue_union __val
-    cdef ccuda.CUlaunchAttributeValue_union* _ptr
-    {{if 'accessPolicyWindow' in found_unions['CUlaunchAttributeValue_union']['members']}}cdef CUaccessPolicyWindow _accessPolicyWindow{{endif}}
-    {{if 'clusterDim' in found_unions['CUlaunchAttributeValue_union']['members']}}cdef _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s _clusterDim{{endif}}
-    {{if 'programmaticEvent' in found_unions['CUlaunchAttributeValue_union']['members']}}cdef _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s _programmaticEvent{{endif}}
+    cdef cydriver.CUlaunchAttributeValue_union __val
+    cdef cydriver.CUlaunchAttributeValue_union* _ptr
+    cdef CUaccessPolicyWindow _accessPolicyWindow
+    cdef anon_struct0 _clusterDim
+    cdef anon_struct1 _programmaticEvent
 {{endif}}
-{{if 'CUlaunchAttribute_st' in found_types}}
+{{if 'struct CUlaunchAttribute_st' in found_types}}
 
 cdef class CUlaunchAttribute_st:
     """
-
     Attributes
     ----------
     id : CUlaunchAttributeID
@@ -916,15 +909,14 @@ cdef class CUlaunchAttribute_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUlaunchAttribute_st  __val
-    cdef ccuda.CUlaunchAttribute_st* _ptr
+    cdef cydriver.CUlaunchAttribute_st __val
+    cdef cydriver.CUlaunchAttribute_st* _ptr
     cdef CUlaunchAttributeValue _value
 {{endif}}
-{{if 'CUlaunchConfig_st' in found_types}}
+{{if 'struct CUlaunchConfig_st' in found_types}}
 
 cdef class CUlaunchConfig_st:
     """
-
     Attributes
     ----------
     gridDimX : unsigned int
@@ -954,13 +946,14 @@ cdef class CUlaunchConfig_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUlaunchConfig_st  __val
-    cdef ccuda.CUlaunchConfig_st* _ptr
+    cdef cydriver.CUlaunchConfig_st __val
+    cdef cydriver.CUlaunchConfig_st* _ptr
     cdef CUstream _hStream
     cdef size_t _attrs_length
-    cdef ccuda.CUlaunchAttribute* _attrs
+    cdef cydriver.CUlaunchAttribute* _attrs
+
 {{endif}}
-{{if 'CUexecAffinitySmCount_st' in found_types}}
+{{if 'struct CUexecAffinitySmCount_st' in found_types}}
 
 cdef class CUexecAffinitySmCount_st:
     """
@@ -977,14 +970,13 @@ cdef class CUexecAffinitySmCount_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUexecAffinitySmCount_st  __val
-    cdef ccuda.CUexecAffinitySmCount_st* _ptr
+    cdef cydriver.CUexecAffinitySmCount_st __val
+    cdef cydriver.CUexecAffinitySmCount_st* _ptr
 {{endif}}
-{{if 'CUexecAffinityParam_st' in found_types}}
+{{if 'struct CUexecAffinityParam_st' in found_types}}
 
-cdef class _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u:
+cdef class anon_union2:
     """
-
     Attributes
     ----------
     smCount : CUexecAffinitySmCount
@@ -996,10 +988,10 @@ cdef class _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st
         Get memory address of class instance
 
     """
-    cdef ccuda.CUexecAffinityParam_st* _ptr
+    cdef cydriver.CUexecAffinityParam_st* _ptr
     cdef CUexecAffinitySmCount _smCount
 {{endif}}
-{{if 'CUexecAffinityParam_st' in found_types}}
+{{if 'struct CUexecAffinityParam_st' in found_types}}
 
 cdef class CUexecAffinityParam_st:
     """
@@ -1009,7 +1001,7 @@ cdef class CUexecAffinityParam_st:
     ----------
     type : CUexecAffinityType
 
-    param : _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u
+    param : anon_union2
 
 
     Methods
@@ -1018,11 +1010,11 @@ cdef class CUexecAffinityParam_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUexecAffinityParam_st  __val
-    cdef ccuda.CUexecAffinityParam_st* _ptr
-    cdef _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u _param
+    cdef cydriver.CUexecAffinityParam_st* _val_ptr
+    cdef cydriver.CUexecAffinityParam_st* _ptr
+    cdef anon_union2 _param
 {{endif}}
-{{if 'CUDA_MEMCPY2D_st' in found_types}}
+{{if 'struct CUDA_MEMCPY2D_st' in found_types}}
 
 cdef class CUDA_MEMCPY2D_st:
     """
@@ -1069,16 +1061,14 @@ cdef class CUDA_MEMCPY2D_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_MEMCPY2D_st  __val
-    cdef ccuda.CUDA_MEMCPY2D_st* _ptr
-    cdef utils.HelperInputVoidPtr _csrcHost
+    cdef cydriver.CUDA_MEMCPY2D_st __val
+    cdef cydriver.CUDA_MEMCPY2D_st* _ptr
     cdef CUdeviceptr _srcDevice
     cdef CUarray _srcArray
-    cdef utils.HelperInputVoidPtr _cdstHost
     cdef CUdeviceptr _dstDevice
     cdef CUarray _dstArray
 {{endif}}
-{{if 'CUDA_MEMCPY3D_st' in found_types}}
+{{if 'struct CUDA_MEMCPY3D_st' in found_types}}
 
 cdef class CUDA_MEMCPY3D_st:
     """
@@ -1144,18 +1134,14 @@ cdef class CUDA_MEMCPY3D_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_MEMCPY3D_st  __val
-    cdef ccuda.CUDA_MEMCPY3D_st* _ptr
-    cdef utils.HelperInputVoidPtr _csrcHost
+    cdef cydriver.CUDA_MEMCPY3D_st __val
+    cdef cydriver.CUDA_MEMCPY3D_st* _ptr
     cdef CUdeviceptr _srcDevice
     cdef CUarray _srcArray
-    cdef utils.HelperInputVoidPtr _creserved0
-    cdef utils.HelperInputVoidPtr _cdstHost
     cdef CUdeviceptr _dstDevice
     cdef CUarray _dstArray
-    cdef utils.HelperInputVoidPtr _creserved1
 {{endif}}
-{{if 'CUDA_MEMCPY3D_PEER_st' in found_types}}
+{{if 'struct CUDA_MEMCPY3D_PEER_st' in found_types}}
 
 cdef class CUDA_MEMCPY3D_PEER_st:
     """
@@ -1222,18 +1208,16 @@ cdef class CUDA_MEMCPY3D_PEER_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_MEMCPY3D_PEER_st  __val
-    cdef ccuda.CUDA_MEMCPY3D_PEER_st* _ptr
-    cdef utils.HelperInputVoidPtr _csrcHost
+    cdef cydriver.CUDA_MEMCPY3D_PEER_st __val
+    cdef cydriver.CUDA_MEMCPY3D_PEER_st* _ptr
     cdef CUdeviceptr _srcDevice
     cdef CUarray _srcArray
     cdef CUcontext _srcContext
-    cdef utils.HelperInputVoidPtr _cdstHost
     cdef CUdeviceptr _dstDevice
     cdef CUarray _dstArray
     cdef CUcontext _dstContext
 {{endif}}
-{{if 'CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
+{{if 'struct CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
 
 cdef class CUDA_ARRAY_DESCRIPTOR_st:
     """
@@ -1256,10 +1240,10 @@ cdef class CUDA_ARRAY_DESCRIPTOR_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_ARRAY_DESCRIPTOR_st  __val
-    cdef ccuda.CUDA_ARRAY_DESCRIPTOR_st* _ptr
+    cdef cydriver.CUDA_ARRAY_DESCRIPTOR_st __val
+    cdef cydriver.CUDA_ARRAY_DESCRIPTOR_st* _ptr
 {{endif}}
-{{if 'CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
+{{if 'struct CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
 
 cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
     """
@@ -1286,14 +1270,13 @@ cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_st  __val
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR_st* _ptr
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_st __val
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR_st* _ptr
 {{endif}}
-{{if 'CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
+{{if 'struct CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
 
-cdef class _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s:
+cdef class anon_struct2:
     """
-
     Attributes
     ----------
     width : unsigned int
@@ -1309,9 +1292,9 @@ cdef class _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st* _ptr
+    cdef cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st* _ptr
 {{endif}}
-{{if 'CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
+{{if 'struct CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
 
 cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
     """
@@ -1319,7 +1302,7 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
 
     Attributes
     ----------
-    tileExtent : _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s
+    tileExtent : anon_struct2
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins.
@@ -1337,11 +1320,11 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st  __val
-    cdef ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st* _ptr
-    cdef _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s _tileExtent
+    cdef cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st __val
+    cdef cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st* _ptr
+    cdef anon_struct2 _tileExtent
 {{endif}}
-{{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
+{{if 'struct CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
 
 cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
     """
@@ -1362,14 +1345,13 @@ cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st  __val
-    cdef ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st* _ptr
+    cdef cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS_st __val
+    cdef cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS_st* _ptr
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s:
+cdef class anon_struct3:
     """
-
     Attributes
     ----------
     hArray : CUarray
@@ -1381,14 +1363,13 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
     cdef CUarray _hArray
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s:
+cdef class anon_struct4:
     """
-
     Attributes
     ----------
     hMipmappedArray : CUmipmappedArray
@@ -1400,14 +1381,13 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
     cdef CUmipmappedArray _hMipmappedArray
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s:
+cdef class anon_struct5:
     """
-
     Attributes
     ----------
     devPtr : CUdeviceptr
@@ -1425,14 +1405,13 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
     cdef CUdeviceptr _devPtr
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s:
+cdef class anon_struct6:
     """
-
     Attributes
     ----------
     devPtr : CUdeviceptr
@@ -1454,14 +1433,13 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
     cdef CUdeviceptr _devPtr
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s:
+cdef class anon_struct7:
     """
-
     Attributes
     ----------
     reserved : List[int]
@@ -1473,24 +1451,23 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u:
+cdef class anon_union3:
     """
-
     Attributes
     ----------
-    array : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s
+    array : anon_struct3
 
-    mipmap : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s
+    mipmap : anon_struct4
 
-    linear : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s
+    linear : anon_struct5
 
-    pitch2D : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s
+    pitch2D : anon_struct6
 
-    reserved : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s
+    reserved : anon_struct7
 
 
     Methods
@@ -1499,14 +1476,14 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s _array
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s _mipmap
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s _linear
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s _pitch2D
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s _reserved
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
+    cdef anon_struct3 _array
+    cdef anon_struct4 _mipmap
+    cdef anon_struct5 _linear
+    cdef anon_struct6 _pitch2D
+    cdef anon_struct7 _reserved
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
 cdef class CUDA_RESOURCE_DESC_st:
     """
@@ -1516,7 +1493,7 @@ cdef class CUDA_RESOURCE_DESC_st:
     ----------
     resType : CUresourcetype
         Resource type
-    res : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u
+    res : anon_union3
 
     flags : unsigned int
         Flags (must be zero)
@@ -1527,11 +1504,11 @@ cdef class CUDA_RESOURCE_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_DESC_st  __val
-    cdef ccuda.CUDA_RESOURCE_DESC_st* _ptr
-    cdef _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u _res
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _val_ptr
+    cdef cydriver.CUDA_RESOURCE_DESC_st* _ptr
+    cdef anon_union3 _res
 {{endif}}
-{{if 'CUDA_TEXTURE_DESC_st' in found_types}}
+{{if 'struct CUDA_TEXTURE_DESC_st' in found_types}}
 
 cdef class CUDA_TEXTURE_DESC_st:
     """
@@ -1566,10 +1543,10 @@ cdef class CUDA_TEXTURE_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_TEXTURE_DESC_st  __val
-    cdef ccuda.CUDA_TEXTURE_DESC_st* _ptr
+    cdef cydriver.CUDA_TEXTURE_DESC_st __val
+    cdef cydriver.CUDA_TEXTURE_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
 
 cdef class CUDA_RESOURCE_VIEW_DESC_st:
     """
@@ -1602,10 +1579,10 @@ cdef class CUDA_RESOURCE_VIEW_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC_st  __val
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC_st* _ptr
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC_st __val
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
+{{if 'struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
 
 cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
     """
@@ -1624,10 +1601,10 @@ cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st  __val
-    cdef ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st* _ptr
+    cdef cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st __val
+    cdef cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st* _ptr
 {{endif}}
-{{if 'CUDA_LAUNCH_PARAMS_st' in found_types}}
+{{if 'struct CUDA_LAUNCH_PARAMS_st' in found_types}}
 
 cdef class CUDA_LAUNCH_PARAMS_st:
     """
@@ -1662,22 +1639,21 @@ cdef class CUDA_LAUNCH_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_LAUNCH_PARAMS_st  __val
-    cdef ccuda.CUDA_LAUNCH_PARAMS_st* _ptr
+    cdef cydriver.CUDA_LAUNCH_PARAMS_st __val
+    cdef cydriver.CUDA_LAUNCH_PARAMS_st* _ptr
     cdef CUfunction _function
     cdef CUstream _hStream
-    cdef utils.HelperKernelParams _ckernelParams
+    cdef utils.HelperKernelParams _cykernelParams
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s:
+cdef class anon_struct8:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -1686,22 +1662,19 @@ cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
-    cdef utils.HelperInputVoidPtr _chandle
-    cdef utils.HelperInputVoidPtr _cname
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u:
+cdef class anon_union4:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s
+    win32 : anon_struct8
 
-    nvSciBufObject : void
+    nvSciBufObject : Any
 
 
     Methods
@@ -1710,11 +1683,10 @@ cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
-    cdef _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s _win32
-    cdef utils.HelperInputVoidPtr _cnvSciBufObject
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
+    cdef anon_struct8 _win32
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     """
@@ -1724,7 +1696,7 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     ----------
     type : CUexternalMemoryHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u
+    handle : anon_union4
 
     size : unsigned long long
         Size of the memory allocation
@@ -1739,11 +1711,11 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st  __val
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
-    cdef _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u _handle
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _val_ptr
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st* _ptr
+    cdef anon_union4 _handle
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
     """
@@ -1766,10 +1738,10 @@ cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st  __val
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st __val
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
     """
@@ -1793,20 +1765,19 @@ cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st  __val
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st __val
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st* _ptr
     cdef CUDA_ARRAY3D_DESCRIPTOR _arrayDesc
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s:
+cdef class anon_struct9:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -1815,22 +1786,19 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDL
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
-    cdef utils.HelperInputVoidPtr _chandle
-    cdef utils.HelperInputVoidPtr _cname
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u:
+cdef class anon_union5:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s
+    win32 : anon_struct9
 
-    nvSciSyncObj : void
+    nvSciSyncObj : Any
 
 
     Methods
@@ -1839,11 +1807,10 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDL
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s _win32
-    cdef utils.HelperInputVoidPtr _cnvSciSyncObj
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
+    cdef anon_struct9 _win32
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     """
@@ -1853,7 +1820,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     ----------
     type : CUexternalSemaphoreHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u
+    handle : anon_union5
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -1866,15 +1833,14 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st  __val
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u _handle
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _val_ptr
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st* _ptr
+    cdef anon_union5 _handle
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s:
+cdef class anon_struct10:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -1886,16 +1852,15 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u:
+cdef class anon_union6:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -1906,14 +1871,12 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
-    cdef utils.HelperInputVoidPtr _cfence
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s:
+cdef class anon_struct11:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -1925,20 +1888,19 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s:
+cdef class anon_struct12:
     """
-
     Attributes
     ----------
-    fence : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s
+    fence : anon_struct10
 
-    nvSciSync : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u
+    nvSciSync : anon_union6
 
-    keyedMutex : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s
+    keyedMutex : anon_struct11
 
     reserved : List[unsigned int]
 
@@ -1949,12 +1911,12 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s _fence
-    cdef _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u _nvSciSync
-    cdef _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s _keyedMutex
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
+    cdef anon_struct10 _fence
+    cdef anon_union6 _nvSciSync
+    cdef anon_struct11 _keyedMutex
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
     """
@@ -1962,7 +1924,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s
+    params : anon_struct12
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS is used to signal
@@ -1982,15 +1944,14 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st  __val
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s _params
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st __val
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st* _ptr
+    cdef anon_struct12 _params
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s:
+cdef class anon_struct13:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -2002,16 +1963,15 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u:
+cdef class anon_union7:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -2022,14 +1982,12 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
-    cdef utils.HelperInputVoidPtr _cfence
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s:
+cdef class anon_struct14:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -2043,20 +2001,19 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s:
+cdef class anon_struct15:
     """
-
     Attributes
     ----------
-    fence : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s
+    fence : anon_struct13
 
-    nvSciSync : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u
+    nvSciSync : anon_union7
 
-    keyedMutex : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s
+    keyedMutex : anon_struct14
 
     reserved : List[unsigned int]
 
@@ -2067,12 +2024,12 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s _fence
-    cdef _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u _nvSciSync
-    cdef _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s _keyedMutex
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
+    cdef anon_struct13 _fence
+    cdef anon_union7 _nvSciSync
+    cdef anon_struct14 _keyedMutex
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
     """
@@ -2080,7 +2037,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS is used to wait on
@@ -2100,11 +2057,11 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st  __val
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
-    cdef _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s _params
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st __val
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st* _ptr
+    cdef anon_struct15 _params
 {{endif}}
-{{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
     """
@@ -2126,14 +2083,16 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st* _ptr
     cdef size_t _extSemArray_length
-    cdef ccuda.CUexternalSemaphore* _extSemArray
+    cdef cydriver.CUexternalSemaphore* _extSemArray
+
     cdef size_t _paramsArray_length
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* _paramsArray
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* _paramsArray
+
 {{endif}}
-{{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
     """
@@ -2155,18 +2114,19 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st* _ptr
     cdef size_t _extSemArray_length
-    cdef ccuda.CUexternalSemaphore* _extSemArray
+    cdef cydriver.CUexternalSemaphore* _extSemArray
+
     cdef size_t _paramsArray_length
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* _paramsArray
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* _paramsArray
+
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u:
+cdef class anon_union8:
     """
-
     Attributes
     ----------
     mipmap : CUmipmappedArray
@@ -2180,15 +2140,14 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st* _ptr
+    cdef cydriver.CUarrayMapInfo_st* _ptr
     cdef CUmipmappedArray _mipmap
     cdef CUarray _array
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s:
+cdef class anon_struct16:
     """
-
     Attributes
     ----------
     level : unsigned int
@@ -2214,13 +2173,12 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_su
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st* _ptr
+    cdef cydriver.CUarrayMapInfo_st* _ptr
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s:
+cdef class anon_struct17:
     """
-
     Attributes
     ----------
     layer : unsigned int
@@ -2236,18 +2194,17 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_su
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st* _ptr
+    cdef cydriver.CUarrayMapInfo_st* _ptr
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u:
+cdef class anon_union9:
     """
-
     Attributes
     ----------
-    sparseLevel : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s
+    sparseLevel : anon_struct16
 
-    miptail : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s
+    miptail : anon_struct17
 
 
     Methods
@@ -2256,15 +2213,14 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st* _ptr
-    cdef _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s _sparseLevel
-    cdef _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s _miptail
+    cdef cydriver.CUarrayMapInfo_st* _ptr
+    cdef anon_struct16 _sparseLevel
+    cdef anon_struct17 _miptail
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u:
+cdef class anon_union10:
     """
-
     Attributes
     ----------
     memHandle : CUmemGenericAllocationHandle
@@ -2276,10 +2232,10 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st* _ptr
+    cdef cydriver.CUarrayMapInfo_st* _ptr
     cdef CUmemGenericAllocationHandle _memHandle
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
 cdef class CUarrayMapInfo_st:
     """
@@ -2290,17 +2246,17 @@ cdef class CUarrayMapInfo_st:
     ----------
     resourceType : CUresourcetype
         Resource type
-    resource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u
+    resource : anon_union8
 
     subresourceType : CUarraySparseSubresourceType
         Sparse subresource type
-    subresource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u
+    subresource : anon_union9
 
     memOperationType : CUmemOperationType
         Memory operation type
     memHandleType : CUmemHandleType
         Memory handle type
-    memHandle : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u
+    memHandle : anon_union10
 
     offset : unsigned long long
         Offset within mip tail  Offset within the memory
@@ -2317,13 +2273,13 @@ cdef class CUarrayMapInfo_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUarrayMapInfo_st  __val
-    cdef ccuda.CUarrayMapInfo_st* _ptr
-    cdef _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u _resource
-    cdef _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u _subresource
-    cdef _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u _memHandle
+    cdef cydriver.CUarrayMapInfo_st* _val_ptr
+    cdef cydriver.CUarrayMapInfo_st* _ptr
+    cdef anon_union8 _resource
+    cdef anon_union9 _subresource
+    cdef anon_union10 _memHandle
 {{endif}}
-{{if 'CUmemLocation_st' in found_types}}
+{{if 'struct CUmemLocation_st' in found_types}}
 
 cdef class CUmemLocation_st:
     """
@@ -2342,23 +2298,22 @@ cdef class CUmemLocation_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemLocation_st  __val
-    cdef ccuda.CUmemLocation_st* _ptr
+    cdef cydriver.CUmemLocation_st __val
+    cdef cydriver.CUmemLocation_st* _ptr
 {{endif}}
-{{if 'CUmemAllocationProp_st' in found_types}}
+{{if 'struct CUmemAllocationProp_st' in found_types}}
 
-cdef class _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s:
+cdef class anon_struct18:
     """
-
     Attributes
     ----------
-    compressionType : unsigned char
+    compressionType : bytes
 
-    gpuDirectRDMACapable : unsigned char
+    gpuDirectRDMACapable : bytes
 
     usage : unsigned short
 
-    reserved : unsigned char
+    reserved : bytes
 
 
     Methods
@@ -2367,9 +2322,9 @@ cdef class _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemAllocationProp_st* _ptr
+    cdef cydriver.CUmemAllocationProp_st* _ptr
 {{endif}}
-{{if 'CUmemAllocationProp_st' in found_types}}
+{{if 'struct CUmemAllocationProp_st' in found_types}}
 
 cdef class CUmemAllocationProp_st:
     """
@@ -2389,7 +2344,7 @@ cdef class CUmemAllocationProp_st:
         structure includes security attributes that define the scope of
         which exported allocations may be tranferred to other processes. In
         all other cases, this field is required to be zero.
-    allocFlags : _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s
+    allocFlags : anon_struct18
 
 
     Methods
@@ -2398,13 +2353,12 @@ cdef class CUmemAllocationProp_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemAllocationProp_st  __val
-    cdef ccuda.CUmemAllocationProp_st* _ptr
+    cdef cydriver.CUmemAllocationProp_st __val
+    cdef cydriver.CUmemAllocationProp_st* _ptr
     cdef CUmemLocation _location
-    cdef utils.HelperInputVoidPtr _cwin32HandleMetaData
-    cdef _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s _allocFlags
+    cdef anon_struct18 _allocFlags
 {{endif}}
-{{if 'CUmemAccessDesc_st' in found_types}}
+{{if 'struct CUmemAccessDesc_st' in found_types}}
 
 cdef class CUmemAccessDesc_st:
     """
@@ -2423,11 +2377,11 @@ cdef class CUmemAccessDesc_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemAccessDesc_st  __val
-    cdef ccuda.CUmemAccessDesc_st* _ptr
+    cdef cydriver.CUmemAccessDesc_st __val
+    cdef cydriver.CUmemAccessDesc_st* _ptr
     cdef CUmemLocation _location
 {{endif}}
-{{if 'CUmemPoolProps_st' in found_types}}
+{{if 'struct CUmemPoolProps_st' in found_types}}
 
 cdef class CUmemPoolProps_st:
     """
@@ -2457,12 +2411,11 @@ cdef class CUmemPoolProps_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemPoolProps_st  __val
-    cdef ccuda.CUmemPoolProps_st* _ptr
+    cdef cydriver.CUmemPoolProps_st __val
+    cdef cydriver.CUmemPoolProps_st* _ptr
     cdef CUmemLocation _location
-    cdef utils.HelperInputVoidPtr _cwin32SecurityAttributes
 {{endif}}
-{{if 'CUmemPoolPtrExportData_st' in found_types}}
+{{if 'struct CUmemPoolPtrExportData_st' in found_types}}
 
 cdef class CUmemPoolPtrExportData_st:
     """
@@ -2479,10 +2432,10 @@ cdef class CUmemPoolPtrExportData_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemPoolPtrExportData_st  __val
-    cdef ccuda.CUmemPoolPtrExportData_st* _ptr
+    cdef cydriver.CUmemPoolPtrExportData_st __val
+    cdef cydriver.CUmemPoolPtrExportData_st* _ptr
 {{endif}}
-{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
     """
@@ -2511,23 +2464,23 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUDA_MEM_ALLOC_NODE_PARAMS_st  __val
-    cdef ccuda.CUDA_MEM_ALLOC_NODE_PARAMS_st* _ptr
+    cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_st __val
+    cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_st* _ptr
     cdef CUmemPoolProps _poolProps
     cdef size_t _accessDescs_length
-    cdef ccuda.CUmemAccessDesc* _accessDescs
+    cdef cydriver.CUmemAccessDesc* _accessDescs
+
     cdef CUdeviceptr _dptr
 {{endif}}
-{{if True or 'CUeglFrame_st' in found_types}}
+{{if True}}
 
-cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
+cdef class anon_union11:
     """
-
     Attributes
     ----------
     pArray : List[CUarray]
 
-    pPitch : List[void]
+    pPitch : List[Any]
 
 
     Methods
@@ -2536,9 +2489,9 @@ cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUeglFrame_st* _ptr
+    cdef cydriver.CUeglFrame_st* _ptr
 {{endif}}
-{{if True or 'CUeglFrame_st' in found_types}}
+{{if True}}
 
 cdef class CUeglFrame_st:
     """
@@ -2548,7 +2501,7 @@ cdef class CUeglFrame_st:
 
     Attributes
     ----------
-    frame : _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u
+    frame : anon_union11
 
     width : unsigned int
         Width of first plane
@@ -2575,15 +2528,78 @@ cdef class CUeglFrame_st:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUeglFrame_st  __val
-    cdef ccuda.CUeglFrame_st* _ptr
-    cdef _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u _frame
+    cdef cydriver.CUeglFrame_st* _val_ptr
+    cdef cydriver.CUeglFrame_st* _ptr
+    cdef anon_union11 _frame
+{{endif}}
+{{if 'CUdeviceptr' in found_types}}
+
+cdef class CUdeviceptr:
+    """
+
+    CUDA device pointer CUdeviceptr is defined as an unsigned integer type whose size matches the size of a pointer on the target platform.
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cydriver.CUdeviceptr __val
+    cdef cydriver.CUdeviceptr* _ptr
+{{endif}}
+{{if 'CUdevice' in found_types}}
+
+cdef class CUdevice:
+    """
+
+    CUDA device
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cydriver.CUdevice __val
+    cdef cydriver.CUdevice* _ptr
+{{endif}}
+{{if 'CUtexObject' in found_types}}
+
+cdef class CUtexObject:
+    """
+
+    An opaque value that represents a CUDA texture object
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cydriver.CUtexObject __val
+    cdef cydriver.CUtexObject* _ptr
+{{endif}}
+{{if 'CUsurfObject' in found_types}}
+
+cdef class CUsurfObject:
+    """
+
+    An opaque value that represents a CUDA surface object
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cydriver.CUsurfObject __val
+    cdef cydriver.CUsurfObject* _ptr
 {{endif}}
 {{if 'CUuuid' in found_types}}
 
 cdef class CUuuid(CUuuid_st):
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -2618,7 +2634,7 @@ cdef class CUipcEventHandle_v1(CUipcEventHandle_st):
 {{endif}}
 {{if 'CUipcEventHandle' in found_types}}
 
-cdef class CUipcEventHandle(CUipcEventHandle_st):
+cdef class CUipcEventHandle(CUipcEventHandle_v1):
     """
     CUDA IPC event handle
 
@@ -2656,7 +2672,7 @@ cdef class CUipcMemHandle_v1(CUipcMemHandle_st):
 {{endif}}
 {{if 'CUipcMemHandle' in found_types}}
 
-cdef class CUipcMemHandle(CUipcMemHandle_st):
+cdef class CUipcMemHandle(CUipcMemHandle_v1):
     """
     CUDA IPC mem handle
 
@@ -2704,7 +2720,7 @@ cdef class CUstreamBatchMemOpParams_v1(CUstreamBatchMemOpParams_union):
 {{endif}}
 {{if 'CUstreamBatchMemOpParams' in found_types}}
 
-cdef class CUstreamBatchMemOpParams(CUstreamBatchMemOpParams_union):
+cdef class CUstreamBatchMemOpParams(CUstreamBatchMemOpParams_v1):
     """
     Per-operation parameters for cuStreamBatchMemOp
 
@@ -2735,7 +2751,6 @@ cdef class CUstreamBatchMemOpParams(CUstreamBatchMemOpParams_union):
 
 cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS(CUDA_BATCH_MEM_OP_NODE_PARAMS_st):
     """
-
     Attributes
     ----------
     ctx : CUcontext
@@ -2794,7 +2809,7 @@ cdef class CUdevprop_v1(CUdevprop_st):
 {{endif}}
 {{if 'CUdevprop' in found_types}}
 
-cdef class CUdevprop(CUdevprop_st):
+cdef class CUdevprop(CUdevprop_v1):
     """
     Legacy device properties
 
@@ -2870,7 +2885,7 @@ cdef class CUaccessPolicyWindow_v1(CUaccessPolicyWindow_st):
 {{endif}}
 {{if 'CUaccessPolicyWindow' in found_types}}
 
-cdef class CUaccessPolicyWindow(CUaccessPolicyWindow_st):
+cdef class CUaccessPolicyWindow(CUaccessPolicyWindow_v1):
     """
     Specifies an access policy for a window, a contiguous extent of
     memory beginning at base_ptr and ending at base_ptr + num_bytes.
@@ -2946,7 +2961,7 @@ cdef class CUDA_KERNEL_NODE_PARAMS_v1(CUDA_KERNEL_NODE_PARAMS_st):
 {{endif}}
 {{if 'CUDA_KERNEL_NODE_PARAMS' in found_types}}
 
-cdef class CUDA_KERNEL_NODE_PARAMS(CUDA_KERNEL_NODE_PARAMS_st):
+cdef class CUDA_KERNEL_NODE_PARAMS(CUDA_KERNEL_NODE_PARAMS_v1):
     """
     GPU kernel node parameters
 
@@ -3012,7 +3027,7 @@ cdef class CUDA_MEMSET_NODE_PARAMS_v1(CUDA_MEMSET_NODE_PARAMS_st):
 {{endif}}
 {{if 'CUDA_MEMSET_NODE_PARAMS' in found_types}}
 
-cdef class CUDA_MEMSET_NODE_PARAMS(CUDA_MEMSET_NODE_PARAMS_st):
+cdef class CUDA_MEMSET_NODE_PARAMS(CUDA_MEMSET_NODE_PARAMS_v1):
     """
     Memset node parameters
 
@@ -3062,7 +3077,7 @@ cdef class CUDA_HOST_NODE_PARAMS_v1(CUDA_HOST_NODE_PARAMS_st):
 {{endif}}
 {{if 'CUDA_HOST_NODE_PARAMS' in found_types}}
 
-cdef class CUDA_HOST_NODE_PARAMS(CUDA_HOST_NODE_PARAMS_st):
+cdef class CUDA_HOST_NODE_PARAMS(CUDA_HOST_NODE_PARAMS_v1):
     """
     Host node parameters
 
@@ -3085,7 +3100,6 @@ cdef class CUDA_HOST_NODE_PARAMS(CUDA_HOST_NODE_PARAMS_st):
 
 cdef class CUlaunchAttributeValue(CUlaunchAttributeValue_union):
     """
-
     Attributes
     ----------
     pad : bytes
@@ -3096,13 +3110,13 @@ cdef class CUlaunchAttributeValue(CUlaunchAttributeValue_union):
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -3119,7 +3133,6 @@ cdef class CUlaunchAttributeValue(CUlaunchAttributeValue_union):
 
 cdef class CUlaunchAttribute(CUlaunchAttribute_st):
     """
-
     Attributes
     ----------
     id : CUlaunchAttributeID
@@ -3139,7 +3152,6 @@ cdef class CUlaunchAttribute(CUlaunchAttribute_st):
 
 cdef class CUlaunchConfig(CUlaunchConfig_st):
     """
-
     Attributes
     ----------
     gridDimX : unsigned int
@@ -3173,9 +3185,8 @@ cdef class CUlaunchConfig(CUlaunchConfig_st):
 {{endif}}
 {{if 'CUkernelNodeAttrValue_v1' in found_types}}
 
-cdef class CUkernelNodeAttrValue_v1(CUlaunchAttributeValue_union):
+cdef class CUkernelNodeAttrValue_v1(CUlaunchAttributeValue):
     """
-
     Attributes
     ----------
     pad : bytes
@@ -3186,13 +3197,13 @@ cdef class CUkernelNodeAttrValue_v1(CUlaunchAttributeValue_union):
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -3207,9 +3218,8 @@ cdef class CUkernelNodeAttrValue_v1(CUlaunchAttributeValue_union):
 {{endif}}
 {{if 'CUkernelNodeAttrValue' in found_types}}
 
-cdef class CUkernelNodeAttrValue(CUlaunchAttributeValue_union):
+cdef class CUkernelNodeAttrValue(CUkernelNodeAttrValue_v1):
     """
-
     Attributes
     ----------
     pad : bytes
@@ -3220,13 +3230,13 @@ cdef class CUkernelNodeAttrValue(CUlaunchAttributeValue_union):
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -3241,9 +3251,8 @@ cdef class CUkernelNodeAttrValue(CUlaunchAttributeValue_union):
 {{endif}}
 {{if 'CUstreamAttrValue_v1' in found_types}}
 
-cdef class CUstreamAttrValue_v1(CUlaunchAttributeValue_union):
+cdef class CUstreamAttrValue_v1(CUlaunchAttributeValue):
     """
-
     Attributes
     ----------
     pad : bytes
@@ -3254,13 +3263,13 @@ cdef class CUstreamAttrValue_v1(CUlaunchAttributeValue_union):
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -3275,9 +3284,8 @@ cdef class CUstreamAttrValue_v1(CUlaunchAttributeValue_union):
 {{endif}}
 {{if 'CUstreamAttrValue' in found_types}}
 
-cdef class CUstreamAttrValue(CUlaunchAttributeValue_union):
+cdef class CUstreamAttrValue(CUstreamAttrValue_v1):
     """
-
     Attributes
     ----------
     pad : bytes
@@ -3288,13 +3296,13 @@ cdef class CUstreamAttrValue(CUlaunchAttributeValue_union):
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -3328,7 +3336,7 @@ cdef class CUexecAffinitySmCount_v1(CUexecAffinitySmCount_st):
 {{endif}}
 {{if 'CUexecAffinitySmCount' in found_types}}
 
-cdef class CUexecAffinitySmCount(CUexecAffinitySmCount_st):
+cdef class CUexecAffinitySmCount(CUexecAffinitySmCount_v1):
     """
     Value for CU_EXEC_AFFINITY_TYPE_SM_COUNT
 
@@ -3355,7 +3363,7 @@ cdef class CUexecAffinityParam_v1(CUexecAffinityParam_st):
     ----------
     type : CUexecAffinityType
 
-    param : _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u
+    param : anon_union2
 
 
     Methods
@@ -3368,7 +3376,7 @@ cdef class CUexecAffinityParam_v1(CUexecAffinityParam_st):
 {{endif}}
 {{if 'CUexecAffinityParam' in found_types}}
 
-cdef class CUexecAffinityParam(CUexecAffinityParam_st):
+cdef class CUexecAffinityParam(CUexecAffinityParam_v1):
     """
     Execution Affinity Parameters
 
@@ -3376,7 +3384,7 @@ cdef class CUexecAffinityParam(CUexecAffinityParam_st):
     ----------
     type : CUexecAffinityType
 
-    param : _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u
+    param : anon_union2
 
 
     Methods
@@ -3438,7 +3446,7 @@ cdef class CUDA_MEMCPY2D_v2(CUDA_MEMCPY2D_st):
 {{endif}}
 {{if 'CUDA_MEMCPY2D' in found_types}}
 
-cdef class CUDA_MEMCPY2D(CUDA_MEMCPY2D_st):
+cdef class CUDA_MEMCPY2D(CUDA_MEMCPY2D_v2):
     """
     2D memory copy parameters
 
@@ -3555,7 +3563,7 @@ cdef class CUDA_MEMCPY3D_v2(CUDA_MEMCPY3D_st):
 {{endif}}
 {{if 'CUDA_MEMCPY3D' in found_types}}
 
-cdef class CUDA_MEMCPY3D(CUDA_MEMCPY3D_st):
+cdef class CUDA_MEMCPY3D(CUDA_MEMCPY3D_v2):
     """
     3D memory copy parameters
 
@@ -3692,7 +3700,7 @@ cdef class CUDA_MEMCPY3D_PEER_v1(CUDA_MEMCPY3D_PEER_st):
 {{endif}}
 {{if 'CUDA_MEMCPY3D_PEER' in found_types}}
 
-cdef class CUDA_MEMCPY3D_PEER(CUDA_MEMCPY3D_PEER_st):
+cdef class CUDA_MEMCPY3D_PEER(CUDA_MEMCPY3D_PEER_v1):
     """
     3D memory cross-context copy parameters
 
@@ -3786,7 +3794,7 @@ cdef class CUDA_ARRAY_DESCRIPTOR_v2(CUDA_ARRAY_DESCRIPTOR_st):
 {{endif}}
 {{if 'CUDA_ARRAY_DESCRIPTOR' in found_types}}
 
-cdef class CUDA_ARRAY_DESCRIPTOR(CUDA_ARRAY_DESCRIPTOR_st):
+cdef class CUDA_ARRAY_DESCRIPTOR(CUDA_ARRAY_DESCRIPTOR_v2):
     """
     Array descriptor
 
@@ -3840,7 +3848,7 @@ cdef class CUDA_ARRAY3D_DESCRIPTOR_v2(CUDA_ARRAY3D_DESCRIPTOR_st):
 {{endif}}
 {{if 'CUDA_ARRAY3D_DESCRIPTOR' in found_types}}
 
-cdef class CUDA_ARRAY3D_DESCRIPTOR(CUDA_ARRAY3D_DESCRIPTOR_st):
+cdef class CUDA_ARRAY3D_DESCRIPTOR(CUDA_ARRAY3D_DESCRIPTOR_v2):
     """
     3D array descriptor
 
@@ -3875,7 +3883,7 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_v1(CUDA_ARRAY_SPARSE_PROPERTIES_st):
 
     Attributes
     ----------
-    tileExtent : _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s
+    tileExtent : anon_struct2
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins.
@@ -3897,13 +3905,13 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_v1(CUDA_ARRAY_SPARSE_PROPERTIES_st):
 {{endif}}
 {{if 'CUDA_ARRAY_SPARSE_PROPERTIES' in found_types}}
 
-cdef class CUDA_ARRAY_SPARSE_PROPERTIES(CUDA_ARRAY_SPARSE_PROPERTIES_st):
+cdef class CUDA_ARRAY_SPARSE_PROPERTIES(CUDA_ARRAY_SPARSE_PROPERTIES_v1):
     """
     CUDA array sparse properties
 
     Attributes
     ----------
-    tileExtent : _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s
+    tileExtent : anon_struct2
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins.
@@ -3948,7 +3956,7 @@ cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_v1(CUDA_ARRAY_MEMORY_REQUIREMENTS_st):
 {{endif}}
 {{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS' in found_types}}
 
-cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS(CUDA_ARRAY_MEMORY_REQUIREMENTS_st):
+cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS(CUDA_ARRAY_MEMORY_REQUIREMENTS_v1):
     """
     CUDA array memory requirements
 
@@ -3979,7 +3987,7 @@ cdef class CUDA_RESOURCE_DESC_v1(CUDA_RESOURCE_DESC_st):
     ----------
     resType : CUresourcetype
         Resource type
-    res : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u
+    res : anon_union3
 
     flags : unsigned int
         Flags (must be zero)
@@ -3994,7 +4002,7 @@ cdef class CUDA_RESOURCE_DESC_v1(CUDA_RESOURCE_DESC_st):
 {{endif}}
 {{if 'CUDA_RESOURCE_DESC' in found_types}}
 
-cdef class CUDA_RESOURCE_DESC(CUDA_RESOURCE_DESC_st):
+cdef class CUDA_RESOURCE_DESC(CUDA_RESOURCE_DESC_v1):
     """
     CUDA Resource descriptor
 
@@ -4002,7 +4010,7 @@ cdef class CUDA_RESOURCE_DESC(CUDA_RESOURCE_DESC_st):
     ----------
     resType : CUresourcetype
         Resource type
-    res : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u
+    res : anon_union3
 
     flags : unsigned int
         Flags (must be zero)
@@ -4054,7 +4062,7 @@ cdef class CUDA_TEXTURE_DESC_v1(CUDA_TEXTURE_DESC_st):
 {{endif}}
 {{if 'CUDA_TEXTURE_DESC' in found_types}}
 
-cdef class CUDA_TEXTURE_DESC(CUDA_TEXTURE_DESC_st):
+cdef class CUDA_TEXTURE_DESC(CUDA_TEXTURE_DESC_v1):
     """
     Texture descriptor
 
@@ -4126,7 +4134,7 @@ cdef class CUDA_RESOURCE_VIEW_DESC_v1(CUDA_RESOURCE_VIEW_DESC_st):
 {{endif}}
 {{if 'CUDA_RESOURCE_VIEW_DESC' in found_types}}
 
-cdef class CUDA_RESOURCE_VIEW_DESC(CUDA_RESOURCE_VIEW_DESC_st):
+cdef class CUDA_RESOURCE_VIEW_DESC(CUDA_RESOURCE_VIEW_DESC_v1):
     """
     Resource view descriptor
 
@@ -4182,7 +4190,7 @@ cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1(CUDA_POINTER_ATTRIBUTE_P2P_TOKEN
 {{endif}}
 {{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS' in found_types}}
 
-cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st):
+cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS(CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1):
     """
     GPU Direct v3 tokens
 
@@ -4240,7 +4248,7 @@ cdef class CUDA_LAUNCH_PARAMS_v1(CUDA_LAUNCH_PARAMS_st):
 {{endif}}
 {{if 'CUDA_LAUNCH_PARAMS' in found_types}}
 
-cdef class CUDA_LAUNCH_PARAMS(CUDA_LAUNCH_PARAMS_st):
+cdef class CUDA_LAUNCH_PARAMS(CUDA_LAUNCH_PARAMS_v1):
     """
     Kernel launch parameters
 
@@ -4285,7 +4293,7 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_
     ----------
     type : CUexternalMemoryHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u
+    handle : anon_union4
 
     size : unsigned long long
         Size of the memory allocation
@@ -4304,7 +4312,7 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_
 {{endif}}
 {{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC' in found_types}}
 
-cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st):
+cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1):
     """
     External memory handle descriptor
 
@@ -4312,7 +4320,7 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC(CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st)
     ----------
     type : CUexternalMemoryHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u
+    handle : anon_union4
 
     size : unsigned long long
         Size of the memory allocation
@@ -4356,7 +4364,7 @@ cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_
 {{endif}}
 {{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC' in found_types}}
 
-cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st):
+cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC(CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1):
     """
     External memory buffer descriptor
 
@@ -4407,7 +4415,7 @@ cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1(CUDA_EXTERNAL_MEMORY_MIP
 {{endif}}
 {{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC' in found_types}}
 
-cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st):
+cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC(CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1):
     """
     External memory mipmap descriptor
 
@@ -4441,7 +4449,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1(CUDA_EXTERNAL_SEMAPHORE_HANDLE
     ----------
     type : CUexternalSemaphoreHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u
+    handle : anon_union5
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -4458,7 +4466,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1(CUDA_EXTERNAL_SEMAPHORE_HANDLE
 {{endif}}
 {{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC' in found_types}}
 
-cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st):
+cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1):
     """
     External semaphore handle descriptor
 
@@ -4466,7 +4474,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC(CUDA_EXTERNAL_SEMAPHORE_HANDLE_DE
     ----------
     type : CUexternalSemaphoreHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u
+    handle : anon_union5
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -4489,7 +4497,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1(CUDA_EXTERNAL_SEMAPHORE_SIGN
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s
+    params : anon_struct12
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS is used to signal
@@ -4513,13 +4521,13 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1(CUDA_EXTERNAL_SEMAPHORE_SIGN
 {{endif}}
 {{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS' in found_types}}
 
-cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st):
+cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS(CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1):
     """
     External semaphore signal parameters
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s
+    params : anon_struct12
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS is used to signal
@@ -4549,7 +4557,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1(CUDA_EXTERNAL_SEMAPHORE_WAIT_P
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS is used to wait on
@@ -4573,13 +4581,13 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1(CUDA_EXTERNAL_SEMAPHORE_WAIT_P
 {{endif}}
 {{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS' in found_types}}
 
-cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st):
+cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS(CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1):
     """
     External semaphore wait parameters
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS is used to wait on
@@ -4627,7 +4635,7 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st
 {{endif}}
 {{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS' in found_types}}
 
-cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st):
+cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS(CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1):
     """
     Semaphore signal node parameters
 
@@ -4675,7 +4683,7 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st):
 {{endif}}
 {{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS' in found_types}}
 
-cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st):
+cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS(CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1):
     """
     Semaphore wait node parameters
 
@@ -4697,6 +4705,20 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS(CUDA_EXT_SEM_WAIT_NODE_PARAMS_st):
     """
     pass
 {{endif}}
+{{if 'CUmemGenericAllocationHandle' in found_types}}
+
+cdef class CUmemGenericAllocationHandle:
+    """
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    cdef cydriver.CUmemGenericAllocationHandle __val
+    cdef cydriver.CUmemGenericAllocationHandle* _ptr
+{{endif}}
 {{if 'CUarrayMapInfo_v1' in found_types}}
 
 cdef class CUarrayMapInfo_v1(CUarrayMapInfo_st):
@@ -4708,17 +4730,17 @@ cdef class CUarrayMapInfo_v1(CUarrayMapInfo_st):
     ----------
     resourceType : CUresourcetype
         Resource type
-    resource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u
+    resource : anon_union8
 
     subresourceType : CUarraySparseSubresourceType
         Sparse subresource type
-    subresource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u
+    subresource : anon_union9
 
     memOperationType : CUmemOperationType
         Memory operation type
     memHandleType : CUmemHandleType
         Memory handle type
-    memHandle : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u
+    memHandle : anon_union10
 
     offset : unsigned long long
         Offset within mip tail  Offset within the memory
@@ -4739,7 +4761,7 @@ cdef class CUarrayMapInfo_v1(CUarrayMapInfo_st):
 {{endif}}
 {{if 'CUarrayMapInfo' in found_types}}
 
-cdef class CUarrayMapInfo(CUarrayMapInfo_st):
+cdef class CUarrayMapInfo(CUarrayMapInfo_v1):
     """
     Specifies the CUDA array or CUDA mipmapped array memory mapping
     information
@@ -4748,17 +4770,17 @@ cdef class CUarrayMapInfo(CUarrayMapInfo_st):
     ----------
     resourceType : CUresourcetype
         Resource type
-    resource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u
+    resource : anon_union8
 
     subresourceType : CUarraySparseSubresourceType
         Sparse subresource type
-    subresource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u
+    subresource : anon_union9
 
     memOperationType : CUmemOperationType
         Memory operation type
     memHandleType : CUmemHandleType
         Memory handle type
-    memHandle : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u
+    memHandle : anon_union10
 
     offset : unsigned long long
         Offset within mip tail  Offset within the memory
@@ -4800,7 +4822,7 @@ cdef class CUmemLocation_v1(CUmemLocation_st):
 {{endif}}
 {{if 'CUmemLocation' in found_types}}
 
-cdef class CUmemLocation(CUmemLocation_st):
+cdef class CUmemLocation(CUmemLocation_v1):
     """
     Specifies a memory location.
 
@@ -4839,7 +4861,7 @@ cdef class CUmemAllocationProp_v1(CUmemAllocationProp_st):
         structure includes security attributes that define the scope of
         which exported allocations may be tranferred to other processes. In
         all other cases, this field is required to be zero.
-    allocFlags : _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s
+    allocFlags : anon_struct18
 
 
     Methods
@@ -4852,7 +4874,7 @@ cdef class CUmemAllocationProp_v1(CUmemAllocationProp_st):
 {{endif}}
 {{if 'CUmemAllocationProp' in found_types}}
 
-cdef class CUmemAllocationProp(CUmemAllocationProp_st):
+cdef class CUmemAllocationProp(CUmemAllocationProp_v1):
     """
     Specifies the allocation properties for a allocation.
 
@@ -4870,7 +4892,7 @@ cdef class CUmemAllocationProp(CUmemAllocationProp_st):
         structure includes security attributes that define the scope of
         which exported allocations may be tranferred to other processes. In
         all other cases, this field is required to be zero.
-    allocFlags : _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s
+    allocFlags : anon_struct18
 
 
     Methods
@@ -4904,7 +4926,7 @@ cdef class CUmemAccessDesc_v1(CUmemAccessDesc_st):
 {{endif}}
 {{if 'CUmemAccessDesc' in found_types}}
 
-cdef class CUmemAccessDesc(CUmemAccessDesc_st):
+cdef class CUmemAccessDesc(CUmemAccessDesc_v1):
     """
     Memory access descriptor
 
@@ -4957,7 +4979,7 @@ cdef class CUmemPoolProps_v1(CUmemPoolProps_st):
 {{endif}}
 {{if 'CUmemPoolProps' in found_types}}
 
-cdef class CUmemPoolProps(CUmemPoolProps_st):
+cdef class CUmemPoolProps(CUmemPoolProps_v1):
     """
     Specifies the properties of allocations made from the pool.
 
@@ -5008,7 +5030,7 @@ cdef class CUmemPoolPtrExportData_v1(CUmemPoolPtrExportData_st):
 {{endif}}
 {{if 'CUmemPoolPtrExportData' in found_types}}
 
-cdef class CUmemPoolPtrExportData(CUmemPoolPtrExportData_st):
+cdef class CUmemPoolPtrExportData(CUmemPoolPtrExportData_v1):
     """
     Opaque data for exporting a pool allocation
 
@@ -5056,7 +5078,7 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS(CUDA_MEM_ALLOC_NODE_PARAMS_st):
     """
     pass
 {{endif}}
-{{if True or 'CUeglFrame_v1' in found_types}}
+{{if True}}
 
 cdef class CUeglFrame_v1(CUeglFrame_st):
     """
@@ -5066,7 +5088,7 @@ cdef class CUeglFrame_v1(CUeglFrame_st):
 
     Attributes
     ----------
-    frame : _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u
+    frame : anon_union11
 
     width : unsigned int
         Width of first plane
@@ -5095,9 +5117,9 @@ cdef class CUeglFrame_v1(CUeglFrame_st):
     """
     pass
 {{endif}}
-{{if True or 'CUeglFrame' in found_types}}
+{{if True}}
 
-cdef class CUeglFrame(CUeglFrame_st):
+cdef class CUeglFrame(CUeglFrame_v1):
     """
     CUDA EGLFrame structure Descriptor - structure defining one frame
     of EGL.  Each frame may contain one or more planes depending on
@@ -5105,7 +5127,7 @@ cdef class CUeglFrame(CUeglFrame_st):
 
     Attributes
     ----------
-    frame : _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u
+    frame : anon_union11
 
     width : unsigned int
         Width of first plane
@@ -5145,8 +5167,8 @@ cdef class cuuint32_t:
         Get memory address of class instance
 
     """
-    cdef ccuda.cuuint32_t  __val
-    cdef ccuda.cuuint32_t* _ptr
+    cdef cydriver.cuuint32_t  __val
+    cdef cydriver.cuuint32_t* _ptr
 {{endif}}
 
 {{if 'cuuint64_t' in found_types}}
@@ -5160,8 +5182,8 @@ cdef class cuuint64_t:
         Get memory address of class instance
 
     """
-    cdef ccuda.cuuint64_t  __val
-    cdef ccuda.cuuint64_t* _ptr
+    cdef cydriver.cuuint64_t  __val
+    cdef cydriver.cuuint64_t* _ptr
 {{endif}}
 
 {{if 'CUdeviceptr_v2' in found_types}}
@@ -5177,25 +5199,8 @@ cdef class CUdeviceptr_v2:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUdeviceptr_v2  __val
-    cdef ccuda.CUdeviceptr_v2* _ptr
-{{endif}}
-
-{{if 'CUdeviceptr' in found_types}}
-
-cdef class CUdeviceptr:
-    """
-
-    CUDA device pointer
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    cdef ccuda.CUdeviceptr  __val
-    cdef ccuda.CUdeviceptr* _ptr
+    cdef cydriver.CUdeviceptr_v2  __val
+    cdef cydriver.CUdeviceptr_v2* _ptr
 {{endif}}
 
 {{if 'CUdevice_v1' in found_types}}
@@ -5211,25 +5216,8 @@ cdef class CUdevice_v1:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUdevice_v1  __val
-    cdef ccuda.CUdevice_v1* _ptr
-{{endif}}
-
-{{if 'CUdevice' in found_types}}
-
-cdef class CUdevice:
-    """
-
-    CUDA device
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    cdef ccuda.CUdevice  __val
-    cdef ccuda.CUdevice* _ptr
+    cdef cydriver.CUdevice_v1  __val
+    cdef cydriver.CUdevice_v1* _ptr
 {{endif}}
 
 {{if 'CUtexObject_v1' in found_types}}
@@ -5245,25 +5233,8 @@ cdef class CUtexObject_v1:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUtexObject_v1  __val
-    cdef ccuda.CUtexObject_v1* _ptr
-{{endif}}
-
-{{if 'CUtexObject' in found_types}}
-
-cdef class CUtexObject:
-    """
-
-    An opaque value that represents a CUDA texture object
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    cdef ccuda.CUtexObject  __val
-    cdef ccuda.CUtexObject* _ptr
+    cdef cydriver.CUtexObject_v1  __val
+    cdef cydriver.CUtexObject_v1* _ptr
 {{endif}}
 
 {{if 'CUsurfObject_v1' in found_types}}
@@ -5279,25 +5250,8 @@ cdef class CUsurfObject_v1:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUsurfObject_v1  __val
-    cdef ccuda.CUsurfObject_v1* _ptr
-{{endif}}
-
-{{if 'CUsurfObject' in found_types}}
-
-cdef class CUsurfObject:
-    """
-
-    An opaque value that represents a CUDA surface object
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    cdef ccuda.CUsurfObject  __val
-    cdef ccuda.CUsurfObject* _ptr
+    cdef cydriver.CUsurfObject_v1  __val
+    cdef cydriver.CUsurfObject_v1* _ptr
 {{endif}}
 
 {{if 'CUmemGenericAllocationHandle_v1' in found_types}}
@@ -5311,26 +5265,11 @@ cdef class CUmemGenericAllocationHandle_v1:
         Get memory address of class instance
 
     """
-    cdef ccuda.CUmemGenericAllocationHandle_v1  __val
-    cdef ccuda.CUmemGenericAllocationHandle_v1* _ptr
-{{endif}}
-
-{{if 'CUmemGenericAllocationHandle' in found_types}}
-
-cdef class CUmemGenericAllocationHandle:
-    """
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    cdef ccuda.CUmemGenericAllocationHandle  __val
-    cdef ccuda.CUmemGenericAllocationHandle* _ptr
+    cdef cydriver.CUmemGenericAllocationHandle_v1  __val
+    cdef cydriver.CUmemGenericAllocationHandle_v1* _ptr
 {{endif}}
 
-{{if True or 'GLenum' in found_types}}
+{{if True}}
 
 cdef class GLenum:
     """
@@ -5341,11 +5280,11 @@ cdef class GLenum:
         Get memory address of class instance
 
     """
-    cdef ccuda.GLenum  __val
-    cdef ccuda.GLenum* _ptr
+    cdef cydriver.GLenum  __val
+    cdef cydriver.GLenum* _ptr
 {{endif}}
 
-{{if True or 'GLuint' in found_types}}
+{{if True}}
 
 cdef class GLuint:
     """
@@ -5356,11 +5295,11 @@ cdef class GLuint:
         Get memory address of class instance
 
     """
-    cdef ccuda.GLuint  __val
-    cdef ccuda.GLuint* _ptr
+    cdef cydriver.GLuint  __val
+    cdef cydriver.GLuint* _ptr
 {{endif}}
 
-{{if True or 'EGLint' in found_types}}
+{{if True}}
 
 cdef class EGLint:
     """
@@ -5371,11 +5310,11 @@ cdef class EGLint:
         Get memory address of class instance
 
     """
-    cdef ccuda.EGLint  __val
-    cdef ccuda.EGLint* _ptr
+    cdef cydriver.EGLint  __val
+    cdef cydriver.EGLint* _ptr
 {{endif}}
 
-{{if True or 'VdpDevice' in found_types}}
+{{if True}}
 
 cdef class VdpDevice:
     """
@@ -5386,11 +5325,11 @@ cdef class VdpDevice:
         Get memory address of class instance
 
     """
-    cdef ccuda.VdpDevice  __val
-    cdef ccuda.VdpDevice* _ptr
+    cdef cydriver.VdpDevice  __val
+    cdef cydriver.VdpDevice* _ptr
 {{endif}}
 
-{{if True or 'VdpGetProcAddress' in found_types}}
+{{if True}}
 
 cdef class VdpGetProcAddress:
     """
@@ -5401,11 +5340,11 @@ cdef class VdpGetProcAddress:
         Get memory address of class instance
 
     """
-    cdef ccuda.VdpGetProcAddress  __val
-    cdef ccuda.VdpGetProcAddress* _ptr
+    cdef cydriver.VdpGetProcAddress  __val
+    cdef cydriver.VdpGetProcAddress* _ptr
 {{endif}}
 
-{{if True or 'VdpVideoSurface' in found_types}}
+{{if True}}
 
 cdef class VdpVideoSurface:
     """
@@ -5416,11 +5355,11 @@ cdef class VdpVideoSurface:
         Get memory address of class instance
 
     """
-    cdef ccuda.VdpVideoSurface  __val
-    cdef ccuda.VdpVideoSurface* _ptr
+    cdef cydriver.VdpVideoSurface  __val
+    cdef cydriver.VdpVideoSurface* _ptr
 {{endif}}
 
-{{if True or 'VdpOutputSurface' in found_types}}
+{{if True}}
 
 cdef class VdpOutputSurface:
     """
@@ -5431,6 +5370,6 @@ cdef class VdpOutputSurface:
         Get memory address of class instance
 
     """
-    cdef ccuda.VdpOutputSurface  __val
-    cdef ccuda.VdpOutputSurface* _ptr
+    cdef cydriver.VdpOutputSurface  __val
+    cdef cydriver.VdpOutputSurface* _ptr
 {{endif}}
diff --git a/cuda/cuda.pyx.in b/cuda/cuda/bindings/driver.pyx.in
similarity index 75%
rename from cuda/cuda.pyx.in
rename to cuda/cuda/bindings/driver.pyx.in
index aef3633a..65345941 100644
--- a/cuda/cuda.pyx.in
+++ b/cuda/cuda/bindings/driver.pyx.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -10,7 +10,7 @@ from enum import IntEnum
 import cython
 import ctypes
 from libc.stdlib cimport calloc, free
-from libc.string cimport memcpy
+from libc cimport string
 from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
 from libc.stddef cimport wchar_t
 from libc.limits cimport CHAR_MIN
@@ -35,16 +35,17 @@ ctypedef unsigned long long int32_t_ptr
 ctypedef unsigned long long int64_t_ptr
 ctypedef unsigned long long unsigned_ptr
 ctypedef unsigned long long unsigned_long_long_ptr
+ctypedef unsigned long long long_long_ptr
 ctypedef unsigned long long size_t_ptr
 ctypedef unsigned long long float_ptr
 ctypedef unsigned long long double_ptr
 ctypedef unsigned long long void_ptr
 
 #: CUDA API version number
-CUDA_VERSION = ccuda.CUDA_VERSION
+CUDA_VERSION = cydriver.CUDA_VERSION
 
 #: CUDA IPC handle size
-CU_IPC_HANDLE_SIZE = ccuda.CU_IPC_HANDLE_SIZE
+CU_IPC_HANDLE_SIZE = cydriver.CU_IPC_HANDLE_SIZE
 
 #: Legacy stream handle
 #:
@@ -52,7 +53,7 @@ CU_IPC_HANDLE_SIZE = ccuda.CU_IPC_HANDLE_SIZE
 #: with legacy synchronization behavior.
 #:
 #: See details of the \link_sync_behavior
-CU_STREAM_LEGACY = ccuda.CU_STREAM_LEGACY
+CU_STREAM_LEGACY = cydriver.CU_STREAM_LEGACY
 
 #: Per-thread stream handle
 #:
@@ -60,44 +61,44 @@ CU_STREAM_LEGACY = ccuda.CU_STREAM_LEGACY
 #: with per-thread synchronization behavior.
 #:
 #: See details of the \link_sync_behavior
-CU_STREAM_PER_THREAD = ccuda.CU_STREAM_PER_THREAD
+CU_STREAM_PER_THREAD = cydriver.CU_STREAM_PER_THREAD
 
-CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW = ccuda.CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW
+CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW = cydriver.CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW
 
-CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE = ccuda.CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE
+CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE = cydriver.CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE
 
-CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION = ccuda.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION
+CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION = cydriver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION
 
-CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = ccuda.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
+CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
 
-CU_KERNEL_NODE_ATTRIBUTE_PRIORITY = ccuda.CU_KERNEL_NODE_ATTRIBUTE_PRIORITY
+CU_KERNEL_NODE_ATTRIBUTE_PRIORITY = cydriver.CU_KERNEL_NODE_ATTRIBUTE_PRIORITY
 
-CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW = ccuda.CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW
+CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW = cydriver.CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW
 
-CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY = ccuda.CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY
+CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY = cydriver.CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY
 
 #: If set, host memory is portable between CUDA contexts. Flag for
 #: :py:obj:`~.cuMemHostAlloc()`
-CU_MEMHOSTALLOC_PORTABLE = ccuda.CU_MEMHOSTALLOC_PORTABLE
+CU_MEMHOSTALLOC_PORTABLE = cydriver.CU_MEMHOSTALLOC_PORTABLE
 
 #: If set, host memory is mapped into CUDA address space and
 #: :py:obj:`~.cuMemHostGetDevicePointer()` may be called on the host
 #: pointer. Flag for :py:obj:`~.cuMemHostAlloc()`
-CU_MEMHOSTALLOC_DEVICEMAP = ccuda.CU_MEMHOSTALLOC_DEVICEMAP
+CU_MEMHOSTALLOC_DEVICEMAP = cydriver.CU_MEMHOSTALLOC_DEVICEMAP
 
 #: If set, host memory is allocated as write-combined - fast to write,
 #: faster to DMA, slow to read except via SSE4 streaming load instruction
 #: (MOVNTDQA). Flag for :py:obj:`~.cuMemHostAlloc()`
-CU_MEMHOSTALLOC_WRITECOMBINED = ccuda.CU_MEMHOSTALLOC_WRITECOMBINED
+CU_MEMHOSTALLOC_WRITECOMBINED = cydriver.CU_MEMHOSTALLOC_WRITECOMBINED
 
 #: If set, host memory is portable between CUDA contexts. Flag for
 #: :py:obj:`~.cuMemHostRegister()`
-CU_MEMHOSTREGISTER_PORTABLE = ccuda.CU_MEMHOSTREGISTER_PORTABLE
+CU_MEMHOSTREGISTER_PORTABLE = cydriver.CU_MEMHOSTREGISTER_PORTABLE
 
 #: If set, host memory is mapped into CUDA address space and
 #: :py:obj:`~.cuMemHostGetDevicePointer()` may be called on the host
 #: pointer. Flag for :py:obj:`~.cuMemHostRegister()`
-CU_MEMHOSTREGISTER_DEVICEMAP = ccuda.CU_MEMHOSTREGISTER_DEVICEMAP
+CU_MEMHOSTREGISTER_DEVICEMAP = cydriver.CU_MEMHOSTREGISTER_DEVICEMAP
 
 #: If set, the passed memory pointer is treated as pointing to some memory-
 #: mapped I/O space, e.g. belonging to a third-party PCIe device. On
@@ -108,7 +109,7 @@ CU_MEMHOSTREGISTER_DEVICEMAP = ccuda.CU_MEMHOSTREGISTER_DEVICEMAP
 #: kernel versions. On all other platforms, it is not supported and
 #: :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` is returned. Flag for
 #: :py:obj:`~.cuMemHostRegister()`
-CU_MEMHOSTREGISTER_IOMEMORY = ccuda.CU_MEMHOSTREGISTER_IOMEMORY
+CU_MEMHOSTREGISTER_IOMEMORY = cydriver.CU_MEMHOSTREGISTER_IOMEMORY
 
 #: If set, the passed memory pointer is treated as pointing to memory that
 #: is considered read-only by the device. On platforms without
@@ -120,14 +121,14 @@ CU_MEMHOSTREGISTER_IOMEMORY = ccuda.CU_MEMHOSTREGISTER_IOMEMORY
 #: this flag with a current context associated with a device that does not
 #: have this attribute set will cause :py:obj:`~.cuMemHostRegister` to
 #: error with :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`.
-CU_MEMHOSTREGISTER_READ_ONLY = ccuda.CU_MEMHOSTREGISTER_READ_ONLY
+CU_MEMHOSTREGISTER_READ_ONLY = cydriver.CU_MEMHOSTREGISTER_READ_ONLY
 
 #: Indicates that the layered sparse CUDA array or CUDA mipmapped array has
 #: a single mip tail region for all layers
-CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL = ccuda.CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL
+CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL = cydriver.CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL
 
 #: Indicates that the external memory object is a dedicated resource
-CUDA_EXTERNAL_MEMORY_DEDICATED = ccuda.CUDA_EXTERNAL_MEMORY_DEDICATED
+CUDA_EXTERNAL_MEMORY_DEDICATED = cydriver.CUDA_EXTERNAL_MEMORY_DEDICATED
 
 #: When the `flags` parameter of
 #: :py:obj:`~.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS` contains this flag, it
@@ -137,7 +138,7 @@ CUDA_EXTERNAL_MEMORY_DEDICATED = ccuda.CUDA_EXTERNAL_MEMORY_DEDICATED
 #: :py:obj:`~.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF`, which otherwise are
 #: performed by default to ensure data coherency with other importers of
 #: the same NvSciBuf memory objects.
-CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC = ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC
+CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC = cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC
 
 #: When the `flags` parameter of
 #: :py:obj:`~.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS` contains this flag, it
@@ -147,108 +148,108 @@ CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC = ccuda.CUDA_EXTERNAL_SEMAP
 #: :py:obj:`~.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF`, which otherwise are
 #: performed by default to ensure data coherency with other importers of
 #: the same NvSciBuf memory objects.
-CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC = ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC
+CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC = cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC
 
 #: When `flags` of :py:obj:`~.cuDeviceGetNvSciSyncAttributes` is set to
 #: this, it indicates that application needs signaler specific
 #: NvSciSyncAttr to be filled by
 #: :py:obj:`~.cuDeviceGetNvSciSyncAttributes`.
-CUDA_NVSCISYNC_ATTR_SIGNAL = ccuda.CUDA_NVSCISYNC_ATTR_SIGNAL
+CUDA_NVSCISYNC_ATTR_SIGNAL = cydriver.CUDA_NVSCISYNC_ATTR_SIGNAL
 
 #: When `flags` of :py:obj:`~.cuDeviceGetNvSciSyncAttributes` is set to
 #: this, it indicates that application needs waiter specific NvSciSyncAttr
 #: to be filled by :py:obj:`~.cuDeviceGetNvSciSyncAttributes`.
-CUDA_NVSCISYNC_ATTR_WAIT = ccuda.CUDA_NVSCISYNC_ATTR_WAIT
+CUDA_NVSCISYNC_ATTR_WAIT = cydriver.CUDA_NVSCISYNC_ATTR_WAIT
 
 #: This flag if set indicates that the memory will be used as a tile pool.
-CU_MEM_CREATE_USAGE_TILE_POOL = ccuda.CU_MEM_CREATE_USAGE_TILE_POOL
+CU_MEM_CREATE_USAGE_TILE_POOL = cydriver.CU_MEM_CREATE_USAGE_TILE_POOL
 
 #: If set, each kernel launched as part of
 #: :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` only waits for prior
 #: work in the stream corresponding to that GPU to complete before the
 #: kernel begins execution.
-CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC = ccuda.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
+CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC = cydriver.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
 
 #: If set, any subsequent work pushed in a stream that participated in a
 #: call to :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` will only wait
 #: for the kernel launched on the GPU corresponding to that stream to
 #: complete before it begins execution.
-CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC = ccuda.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
+CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC = cydriver.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
 
 #: If set, the CUDA array is a collection of layers, where each layer is
 #: either a 1D or a 2D array and the Depth member of
 #: CUDA_ARRAY3D_DESCRIPTOR specifies the number of layers, not the depth of
 #: a 3D array.
-CUDA_ARRAY3D_LAYERED = ccuda.CUDA_ARRAY3D_LAYERED
+CUDA_ARRAY3D_LAYERED = cydriver.CUDA_ARRAY3D_LAYERED
 
 #: Deprecated, use CUDA_ARRAY3D_LAYERED
-CUDA_ARRAY3D_2DARRAY = ccuda.CUDA_ARRAY3D_2DARRAY
+CUDA_ARRAY3D_2DARRAY = cydriver.CUDA_ARRAY3D_2DARRAY
 
 #: This flag must be set in order to bind a surface reference to the CUDA
 #: array
-CUDA_ARRAY3D_SURFACE_LDST = ccuda.CUDA_ARRAY3D_SURFACE_LDST
+CUDA_ARRAY3D_SURFACE_LDST = cydriver.CUDA_ARRAY3D_SURFACE_LDST
 
 #: If set, the CUDA array is a collection of six 2D arrays, representing
 #: faces of a cube. The width of such a CUDA array must be equal to its
 #: height, and Depth must be six. If :py:obj:`~.CUDA_ARRAY3D_LAYERED` flag
 #: is also set, then the CUDA array is a collection of cubemaps and Depth
 #: must be a multiple of six.
-CUDA_ARRAY3D_CUBEMAP = ccuda.CUDA_ARRAY3D_CUBEMAP
+CUDA_ARRAY3D_CUBEMAP = cydriver.CUDA_ARRAY3D_CUBEMAP
 
 #: This flag must be set in order to perform texture gather operations on a
 #: CUDA array.
-CUDA_ARRAY3D_TEXTURE_GATHER = ccuda.CUDA_ARRAY3D_TEXTURE_GATHER
+CUDA_ARRAY3D_TEXTURE_GATHER = cydriver.CUDA_ARRAY3D_TEXTURE_GATHER
 
 #: This flag if set indicates that the CUDA array is a DEPTH_TEXTURE.
-CUDA_ARRAY3D_DEPTH_TEXTURE = ccuda.CUDA_ARRAY3D_DEPTH_TEXTURE
+CUDA_ARRAY3D_DEPTH_TEXTURE = cydriver.CUDA_ARRAY3D_DEPTH_TEXTURE
 
 #: This flag indicates that the CUDA array may be bound as a color target
 #: in an external graphics API
-CUDA_ARRAY3D_COLOR_ATTACHMENT = ccuda.CUDA_ARRAY3D_COLOR_ATTACHMENT
+CUDA_ARRAY3D_COLOR_ATTACHMENT = cydriver.CUDA_ARRAY3D_COLOR_ATTACHMENT
 
 #: This flag if set indicates that the CUDA array or CUDA mipmapped array
 #: is a sparse CUDA array or CUDA mipmapped array respectively
-CUDA_ARRAY3D_SPARSE = ccuda.CUDA_ARRAY3D_SPARSE
+CUDA_ARRAY3D_SPARSE = cydriver.CUDA_ARRAY3D_SPARSE
 
 #: This flag if set indicates that the CUDA array or CUDA mipmapped array
 #: will allow deferred memory mapping
-CUDA_ARRAY3D_DEFERRED_MAPPING = ccuda.CUDA_ARRAY3D_DEFERRED_MAPPING
+CUDA_ARRAY3D_DEFERRED_MAPPING = cydriver.CUDA_ARRAY3D_DEFERRED_MAPPING
 
 #: Override the texref format with a format inferred from the array. Flag
 #: for :py:obj:`~.cuTexRefSetArray()`
-CU_TRSA_OVERRIDE_FORMAT = ccuda.CU_TRSA_OVERRIDE_FORMAT
+CU_TRSA_OVERRIDE_FORMAT = cydriver.CU_TRSA_OVERRIDE_FORMAT
 
 #: Read the texture as integers rather than promoting the values to floats
 #: in the range [0,1]. Flag for :py:obj:`~.cuTexRefSetFlags()` and
 #: :py:obj:`~.cuTexObjectCreate()`
-CU_TRSF_READ_AS_INTEGER = ccuda.CU_TRSF_READ_AS_INTEGER
+CU_TRSF_READ_AS_INTEGER = cydriver.CU_TRSF_READ_AS_INTEGER
 
 #: Use normalized texture coordinates in the range [0,1) instead of
 #: [0,dim). Flag for :py:obj:`~.cuTexRefSetFlags()` and
 #: :py:obj:`~.cuTexObjectCreate()`
-CU_TRSF_NORMALIZED_COORDINATES = ccuda.CU_TRSF_NORMALIZED_COORDINATES
+CU_TRSF_NORMALIZED_COORDINATES = cydriver.CU_TRSF_NORMALIZED_COORDINATES
 
 #: Perform sRGB->linear conversion during texture read. Flag for
 #: :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
-CU_TRSF_SRGB = ccuda.CU_TRSF_SRGB
+CU_TRSF_SRGB = cydriver.CU_TRSF_SRGB
 
 #: Disable any trilinear filtering optimizations. Flag for
 #: :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
-CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION = ccuda.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
+CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION = cydriver.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
 
 #: Enable seamless cube map filtering. Flag for
 #: :py:obj:`~.cuTexObjectCreate()`
-CU_TRSF_SEAMLESS_CUBEMAP = ccuda.CU_TRSF_SEAMLESS_CUBEMAP
+CU_TRSF_SEAMLESS_CUBEMAP = cydriver.CU_TRSF_SEAMLESS_CUBEMAP
 
 #: C++ compile time constant for CU_LAUNCH_PARAM_END
-CU_LAUNCH_PARAM_END_AS_INT = ccuda.CU_LAUNCH_PARAM_END_AS_INT
+CU_LAUNCH_PARAM_END_AS_INT = cydriver.CU_LAUNCH_PARAM_END_AS_INT
 
 #: End of array terminator for the `extra` parameter to
 #: :py:obj:`~.cuLaunchKernel`
-CU_LAUNCH_PARAM_END = ccuda.CU_LAUNCH_PARAM_END
+CU_LAUNCH_PARAM_END = cydriver.CU_LAUNCH_PARAM_END
 
 #: C++ compile time constant for CU_LAUNCH_PARAM_BUFFER_POINTER
-CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT = ccuda.CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT
+CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT = cydriver.CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT
 
 #: Indicator that the next value in the `extra` parameter to
 #: :py:obj:`~.cuLaunchKernel` will be a pointer to a buffer containing all
@@ -257,10 +258,10 @@ CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT = ccuda.CU_LAUNCH_PARAM_BUFFER_POINTER_AS_
 #: If :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE` is not also specified in the
 #: `extra` array, then :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER` will have
 #: no effect.
-CU_LAUNCH_PARAM_BUFFER_POINTER = ccuda.CU_LAUNCH_PARAM_BUFFER_POINTER
+CU_LAUNCH_PARAM_BUFFER_POINTER = cydriver.CU_LAUNCH_PARAM_BUFFER_POINTER
 
 #: C++ compile time constant for CU_LAUNCH_PARAM_BUFFER_SIZE
-CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT = ccuda.CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT
+CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT = cydriver.CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT
 
 #: Indicator that the next value in the `extra` parameter to
 #: :py:obj:`~.cuLaunchKernel` will be a pointer to a size_t which contains
@@ -269,24 +270,24 @@ CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT = ccuda.CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT
 #: :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER` also be specified in the
 #: `extra` array if the value associated with
 #: :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE` is not zero.
-CU_LAUNCH_PARAM_BUFFER_SIZE = ccuda.CU_LAUNCH_PARAM_BUFFER_SIZE
+CU_LAUNCH_PARAM_BUFFER_SIZE = cydriver.CU_LAUNCH_PARAM_BUFFER_SIZE
 
 #: For texture references loaded into the module, use default texunit from
 #: texture reference.
-CU_PARAM_TR_DEFAULT = ccuda.CU_PARAM_TR_DEFAULT
+CU_PARAM_TR_DEFAULT = cydriver.CU_PARAM_TR_DEFAULT
 
 #: Device that represents the CPU
-CU_DEVICE_CPU = ccuda.CU_DEVICE_CPU
+CU_DEVICE_CPU = cydriver.CU_DEVICE_CPU
 
 #: Device that represents an invalid device
-CU_DEVICE_INVALID = ccuda.CU_DEVICE_INVALID
+CU_DEVICE_INVALID = cydriver.CU_DEVICE_INVALID
 
 #: Maximum number of planes per frame
-MAX_PLANES = ccuda.MAX_PLANES
+MAX_PLANES = cydriver.MAX_PLANES
 
 #: Indicates that timeout for :py:obj:`~.cuEGLStreamConsumerAcquireFrame`
 #: is infinite.
-CUDA_EGL_INFINITE_TIMEOUT = ccuda.CUDA_EGL_INFINITE_TIMEOUT
+CUDA_EGL_INFINITE_TIMEOUT = cydriver.CUDA_EGL_INFINITE_TIMEOUT
 
 {{if 'CUipcMem_flags_enum' in found_types}}
 
@@ -297,7 +298,7 @@ class CUipcMem_flags(IntEnum):
     {{if 'CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS' in found_values}}
 
     #: Automatically enable peer access between remote devices as needed
-    CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = ccuda.CUipcMem_flags_enum.CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS{{endif}}
+    CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS = cydriver.CUipcMem_flags_enum.CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS{{endif}}
 {{endif}}
 {{if 'CUmemAttach_flags_enum' in found_types}}
 
@@ -308,16 +309,16 @@ class CUmemAttach_flags(IntEnum):
     {{if 'CU_MEM_ATTACH_GLOBAL' in found_values}}
 
     #: Memory can be accessed by any stream on any device
-    CU_MEM_ATTACH_GLOBAL = ccuda.CUmemAttach_flags_enum.CU_MEM_ATTACH_GLOBAL{{endif}}
+    CU_MEM_ATTACH_GLOBAL = cydriver.CUmemAttach_flags_enum.CU_MEM_ATTACH_GLOBAL{{endif}}
     {{if 'CU_MEM_ATTACH_HOST' in found_values}}
 
     #: Memory cannot be accessed by any stream on any device
-    CU_MEM_ATTACH_HOST = ccuda.CUmemAttach_flags_enum.CU_MEM_ATTACH_HOST{{endif}}
+    CU_MEM_ATTACH_HOST = cydriver.CUmemAttach_flags_enum.CU_MEM_ATTACH_HOST{{endif}}
     {{if 'CU_MEM_ATTACH_SINGLE' in found_values}}
 
     #: Memory can only be accessed by a single stream on the associated
     #: device
-    CU_MEM_ATTACH_SINGLE = ccuda.CUmemAttach_flags_enum.CU_MEM_ATTACH_SINGLE{{endif}}
+    CU_MEM_ATTACH_SINGLE = cydriver.CUmemAttach_flags_enum.CU_MEM_ATTACH_SINGLE{{endif}}
 {{endif}}
 {{if 'CUctx_flags_enum' in found_types}}
 
@@ -328,35 +329,35 @@ class CUctx_flags(IntEnum):
     {{if 'CU_CTX_SCHED_AUTO' in found_values}}
 
     #: Automatic scheduling
-    CU_CTX_SCHED_AUTO = ccuda.CUctx_flags_enum.CU_CTX_SCHED_AUTO{{endif}}
+    CU_CTX_SCHED_AUTO = cydriver.CUctx_flags_enum.CU_CTX_SCHED_AUTO{{endif}}
     {{if 'CU_CTX_SCHED_SPIN' in found_values}}
 
     #: Set spin as default scheduling
-    CU_CTX_SCHED_SPIN = ccuda.CUctx_flags_enum.CU_CTX_SCHED_SPIN{{endif}}
+    CU_CTX_SCHED_SPIN = cydriver.CUctx_flags_enum.CU_CTX_SCHED_SPIN{{endif}}
     {{if 'CU_CTX_SCHED_YIELD' in found_values}}
 
     #: Set yield as default scheduling
-    CU_CTX_SCHED_YIELD = ccuda.CUctx_flags_enum.CU_CTX_SCHED_YIELD{{endif}}
+    CU_CTX_SCHED_YIELD = cydriver.CUctx_flags_enum.CU_CTX_SCHED_YIELD{{endif}}
     {{if 'CU_CTX_SCHED_BLOCKING_SYNC' in found_values}}
 
     #: Set blocking synchronization as default scheduling
-    CU_CTX_SCHED_BLOCKING_SYNC = ccuda.CUctx_flags_enum.CU_CTX_SCHED_BLOCKING_SYNC{{endif}}
+    CU_CTX_SCHED_BLOCKING_SYNC = cydriver.CUctx_flags_enum.CU_CTX_SCHED_BLOCKING_SYNC{{endif}}
     {{if 'CU_CTX_BLOCKING_SYNC' in found_values}}
 
     #: Set blocking synchronization as default scheduling [Deprecated]
-    CU_CTX_BLOCKING_SYNC = ccuda.CUctx_flags_enum.CU_CTX_BLOCKING_SYNC{{endif}}
+    CU_CTX_BLOCKING_SYNC = cydriver.CUctx_flags_enum.CU_CTX_BLOCKING_SYNC{{endif}}
     {{if 'CU_CTX_SCHED_MASK' in found_values}}
-    CU_CTX_SCHED_MASK = ccuda.CUctx_flags_enum.CU_CTX_SCHED_MASK{{endif}}
+    CU_CTX_SCHED_MASK = cydriver.CUctx_flags_enum.CU_CTX_SCHED_MASK{{endif}}
     {{if 'CU_CTX_MAP_HOST' in found_values}}
 
     #: [Deprecated]
-    CU_CTX_MAP_HOST = ccuda.CUctx_flags_enum.CU_CTX_MAP_HOST{{endif}}
+    CU_CTX_MAP_HOST = cydriver.CUctx_flags_enum.CU_CTX_MAP_HOST{{endif}}
     {{if 'CU_CTX_LMEM_RESIZE_TO_MAX' in found_values}}
 
     #: Keep local memory allocation after launch
-    CU_CTX_LMEM_RESIZE_TO_MAX = ccuda.CUctx_flags_enum.CU_CTX_LMEM_RESIZE_TO_MAX{{endif}}
+    CU_CTX_LMEM_RESIZE_TO_MAX = cydriver.CUctx_flags_enum.CU_CTX_LMEM_RESIZE_TO_MAX{{endif}}
     {{if 'CU_CTX_FLAGS_MASK' in found_values}}
-    CU_CTX_FLAGS_MASK = ccuda.CUctx_flags_enum.CU_CTX_FLAGS_MASK{{endif}}
+    CU_CTX_FLAGS_MASK = cydriver.CUctx_flags_enum.CU_CTX_FLAGS_MASK{{endif}}
 {{endif}}
 {{if 'CUevent_sched_flags_enum' in found_types}}
 
@@ -367,19 +368,19 @@ class CUevent_sched_flags(IntEnum):
     {{if 'CU_EVENT_SCHED_AUTO' in found_values}}
 
     #: Automatic scheduling
-    CU_EVENT_SCHED_AUTO = ccuda.CUevent_sched_flags_enum.CU_EVENT_SCHED_AUTO{{endif}}
+    CU_EVENT_SCHED_AUTO = cydriver.CUevent_sched_flags_enum.CU_EVENT_SCHED_AUTO{{endif}}
     {{if 'CU_EVENT_SCHED_SPIN' in found_values}}
 
     #: Set spin as default scheduling
-    CU_EVENT_SCHED_SPIN = ccuda.CUevent_sched_flags_enum.CU_EVENT_SCHED_SPIN{{endif}}
+    CU_EVENT_SCHED_SPIN = cydriver.CUevent_sched_flags_enum.CU_EVENT_SCHED_SPIN{{endif}}
     {{if 'CU_EVENT_SCHED_YIELD' in found_values}}
 
     #: Set yield as default scheduling
-    CU_EVENT_SCHED_YIELD = ccuda.CUevent_sched_flags_enum.CU_EVENT_SCHED_YIELD{{endif}}
+    CU_EVENT_SCHED_YIELD = cydriver.CUevent_sched_flags_enum.CU_EVENT_SCHED_YIELD{{endif}}
     {{if 'CU_EVENT_SCHED_BLOCKING_SYNC' in found_values}}
 
     #: Set blocking synchronization as default scheduling
-    CU_EVENT_SCHED_BLOCKING_SYNC = ccuda.CUevent_sched_flags_enum.CU_EVENT_SCHED_BLOCKING_SYNC{{endif}}
+    CU_EVENT_SCHED_BLOCKING_SYNC = cydriver.CUevent_sched_flags_enum.CU_EVENT_SCHED_BLOCKING_SYNC{{endif}}
 {{endif}}
 {{if 'cl_event_flags_enum' in found_types}}
 
@@ -390,19 +391,19 @@ class cl_event_flags(IntEnum):
     {{if 'NVCL_EVENT_SCHED_AUTO' in found_values}}
 
     #: Automatic scheduling
-    NVCL_EVENT_SCHED_AUTO = ccuda.cl_event_flags_enum.NVCL_EVENT_SCHED_AUTO{{endif}}
+    NVCL_EVENT_SCHED_AUTO = cydriver.cl_event_flags_enum.NVCL_EVENT_SCHED_AUTO{{endif}}
     {{if 'NVCL_EVENT_SCHED_SPIN' in found_values}}
 
     #: Set spin as default scheduling
-    NVCL_EVENT_SCHED_SPIN = ccuda.cl_event_flags_enum.NVCL_EVENT_SCHED_SPIN{{endif}}
+    NVCL_EVENT_SCHED_SPIN = cydriver.cl_event_flags_enum.NVCL_EVENT_SCHED_SPIN{{endif}}
     {{if 'NVCL_EVENT_SCHED_YIELD' in found_values}}
 
     #: Set yield as default scheduling
-    NVCL_EVENT_SCHED_YIELD = ccuda.cl_event_flags_enum.NVCL_EVENT_SCHED_YIELD{{endif}}
+    NVCL_EVENT_SCHED_YIELD = cydriver.cl_event_flags_enum.NVCL_EVENT_SCHED_YIELD{{endif}}
     {{if 'NVCL_EVENT_SCHED_BLOCKING_SYNC' in found_values}}
 
     #: Set blocking synchronization as default scheduling
-    NVCL_EVENT_SCHED_BLOCKING_SYNC = ccuda.cl_event_flags_enum.NVCL_EVENT_SCHED_BLOCKING_SYNC{{endif}}
+    NVCL_EVENT_SCHED_BLOCKING_SYNC = cydriver.cl_event_flags_enum.NVCL_EVENT_SCHED_BLOCKING_SYNC{{endif}}
 {{endif}}
 {{if 'cl_context_flags_enum' in found_types}}
 
@@ -413,19 +414,19 @@ class cl_context_flags(IntEnum):
     {{if 'NVCL_CTX_SCHED_AUTO' in found_values}}
 
     #: Automatic scheduling
-    NVCL_CTX_SCHED_AUTO = ccuda.cl_context_flags_enum.NVCL_CTX_SCHED_AUTO{{endif}}
+    NVCL_CTX_SCHED_AUTO = cydriver.cl_context_flags_enum.NVCL_CTX_SCHED_AUTO{{endif}}
     {{if 'NVCL_CTX_SCHED_SPIN' in found_values}}
 
     #: Set spin as default scheduling
-    NVCL_CTX_SCHED_SPIN = ccuda.cl_context_flags_enum.NVCL_CTX_SCHED_SPIN{{endif}}
+    NVCL_CTX_SCHED_SPIN = cydriver.cl_context_flags_enum.NVCL_CTX_SCHED_SPIN{{endif}}
     {{if 'NVCL_CTX_SCHED_YIELD' in found_values}}
 
     #: Set yield as default scheduling
-    NVCL_CTX_SCHED_YIELD = ccuda.cl_context_flags_enum.NVCL_CTX_SCHED_YIELD{{endif}}
+    NVCL_CTX_SCHED_YIELD = cydriver.cl_context_flags_enum.NVCL_CTX_SCHED_YIELD{{endif}}
     {{if 'NVCL_CTX_SCHED_BLOCKING_SYNC' in found_values}}
 
     #: Set blocking synchronization as default scheduling
-    NVCL_CTX_SCHED_BLOCKING_SYNC = ccuda.cl_context_flags_enum.NVCL_CTX_SCHED_BLOCKING_SYNC{{endif}}
+    NVCL_CTX_SCHED_BLOCKING_SYNC = cydriver.cl_context_flags_enum.NVCL_CTX_SCHED_BLOCKING_SYNC{{endif}}
 {{endif}}
 {{if 'CUstream_flags_enum' in found_types}}
 
@@ -436,11 +437,11 @@ class CUstream_flags(IntEnum):
     {{if 'CU_STREAM_DEFAULT' in found_values}}
 
     #: Default stream flag
-    CU_STREAM_DEFAULT = ccuda.CUstream_flags_enum.CU_STREAM_DEFAULT{{endif}}
+    CU_STREAM_DEFAULT = cydriver.CUstream_flags_enum.CU_STREAM_DEFAULT{{endif}}
     {{if 'CU_STREAM_NON_BLOCKING' in found_values}}
 
     #: Stream does not synchronize with stream 0 (the NULL stream)
-    CU_STREAM_NON_BLOCKING = ccuda.CUstream_flags_enum.CU_STREAM_NON_BLOCKING{{endif}}
+    CU_STREAM_NON_BLOCKING = cydriver.CUstream_flags_enum.CU_STREAM_NON_BLOCKING{{endif}}
 {{endif}}
 {{if 'CUevent_flags_enum' in found_types}}
 
@@ -451,20 +452,20 @@ class CUevent_flags(IntEnum):
     {{if 'CU_EVENT_DEFAULT' in found_values}}
 
     #: Default event flag
-    CU_EVENT_DEFAULT = ccuda.CUevent_flags_enum.CU_EVENT_DEFAULT{{endif}}
+    CU_EVENT_DEFAULT = cydriver.CUevent_flags_enum.CU_EVENT_DEFAULT{{endif}}
     {{if 'CU_EVENT_BLOCKING_SYNC' in found_values}}
 
     #: Event uses blocking synchronization
-    CU_EVENT_BLOCKING_SYNC = ccuda.CUevent_flags_enum.CU_EVENT_BLOCKING_SYNC{{endif}}
+    CU_EVENT_BLOCKING_SYNC = cydriver.CUevent_flags_enum.CU_EVENT_BLOCKING_SYNC{{endif}}
     {{if 'CU_EVENT_DISABLE_TIMING' in found_values}}
 
     #: Event will not record timing data
-    CU_EVENT_DISABLE_TIMING = ccuda.CUevent_flags_enum.CU_EVENT_DISABLE_TIMING{{endif}}
+    CU_EVENT_DISABLE_TIMING = cydriver.CUevent_flags_enum.CU_EVENT_DISABLE_TIMING{{endif}}
     {{if 'CU_EVENT_INTERPROCESS' in found_values}}
 
     #: Event is suitable for interprocess use. CU_EVENT_DISABLE_TIMING must
     #: be set
-    CU_EVENT_INTERPROCESS = ccuda.CUevent_flags_enum.CU_EVENT_INTERPROCESS{{endif}}
+    CU_EVENT_INTERPROCESS = cydriver.CUevent_flags_enum.CU_EVENT_INTERPROCESS{{endif}}
 {{endif}}
 {{if 'CUevent_record_flags_enum' in found_types}}
 
@@ -475,13 +476,13 @@ class CUevent_record_flags(IntEnum):
     {{if 'CU_EVENT_RECORD_DEFAULT' in found_values}}
 
     #: Default event record flag
-    CU_EVENT_RECORD_DEFAULT = ccuda.CUevent_record_flags_enum.CU_EVENT_RECORD_DEFAULT{{endif}}
+    CU_EVENT_RECORD_DEFAULT = cydriver.CUevent_record_flags_enum.CU_EVENT_RECORD_DEFAULT{{endif}}
     {{if 'CU_EVENT_RECORD_EXTERNAL' in found_values}}
 
     #: When using stream capture, create an event record node instead of
     #: the default behavior. This flag is invalid when used outside of
     #: capture.
-    CU_EVENT_RECORD_EXTERNAL = ccuda.CUevent_record_flags_enum.CU_EVENT_RECORD_EXTERNAL{{endif}}
+    CU_EVENT_RECORD_EXTERNAL = cydriver.CUevent_record_flags_enum.CU_EVENT_RECORD_EXTERNAL{{endif}}
 {{endif}}
 {{if 'CUevent_wait_flags_enum' in found_types}}
 
@@ -492,12 +493,12 @@ class CUevent_wait_flags(IntEnum):
     {{if 'CU_EVENT_WAIT_DEFAULT' in found_values}}
 
     #: Default event wait flag
-    CU_EVENT_WAIT_DEFAULT = ccuda.CUevent_wait_flags_enum.CU_EVENT_WAIT_DEFAULT{{endif}}
+    CU_EVENT_WAIT_DEFAULT = cydriver.CUevent_wait_flags_enum.CU_EVENT_WAIT_DEFAULT{{endif}}
     {{if 'CU_EVENT_WAIT_EXTERNAL' in found_values}}
 
     #: When using stream capture, create an event wait node instead of the
     #: default behavior. This flag is invalid when used outside of capture.
-    CU_EVENT_WAIT_EXTERNAL = ccuda.CUevent_wait_flags_enum.CU_EVENT_WAIT_EXTERNAL{{endif}}
+    CU_EVENT_WAIT_EXTERNAL = cydriver.CUevent_wait_flags_enum.CU_EVENT_WAIT_EXTERNAL{{endif}}
 {{endif}}
 {{if 'CUstreamWaitValue_flags_enum' in found_types}}
 
@@ -511,21 +512,21 @@ class CUstreamWaitValue_flags(IntEnum):
     #: Wait until (int32_t)(*addr - value) >= 0 (or int64_t for 64 bit
     #: values). Note this is a cyclic comparison which ignores wraparound.
     #: (Default behavior.)
-    CU_STREAM_WAIT_VALUE_GEQ = ccuda.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_GEQ{{endif}}
+    CU_STREAM_WAIT_VALUE_GEQ = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_GEQ{{endif}}
     {{if 'CU_STREAM_WAIT_VALUE_EQ' in found_values}}
 
     #: Wait until *addr == value.
-    CU_STREAM_WAIT_VALUE_EQ = ccuda.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_EQ{{endif}}
+    CU_STREAM_WAIT_VALUE_EQ = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_EQ{{endif}}
     {{if 'CU_STREAM_WAIT_VALUE_AND' in found_values}}
 
     #: Wait until (*addr & value) != 0.
-    CU_STREAM_WAIT_VALUE_AND = ccuda.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_AND{{endif}}
+    CU_STREAM_WAIT_VALUE_AND = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_AND{{endif}}
     {{if 'CU_STREAM_WAIT_VALUE_NOR' in found_values}}
 
     #: Wait until ~(*addr | value) != 0. Support for this operation can be
     #: queried with :py:obj:`~.cuDeviceGetAttribute()` and
     #: :py:obj:`~.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR`.
-    CU_STREAM_WAIT_VALUE_NOR = ccuda.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_NOR{{endif}}
+    CU_STREAM_WAIT_VALUE_NOR = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_NOR{{endif}}
     {{if 'CU_STREAM_WAIT_VALUE_FLUSH' in found_values}}
 
     #: Follow the wait operation with a flush of outstanding remote writes.
@@ -538,7 +539,7 @@ class CUstreamWaitValue_flags(IntEnum):
     #: work needs to observe the first write. Support for this operation is
     #: restricted to selected platforms and can be queried with
     #: :py:obj:`~.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES`.
-    CU_STREAM_WAIT_VALUE_FLUSH = ccuda.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_FLUSH{{endif}}
+    CU_STREAM_WAIT_VALUE_FLUSH = cydriver.CUstreamWaitValue_flags_enum.CU_STREAM_WAIT_VALUE_FLUSH{{endif}}
 {{endif}}
 {{if 'CUstreamWriteValue_flags_enum' in found_types}}
 
@@ -549,7 +550,7 @@ class CUstreamWriteValue_flags(IntEnum):
     {{if 'CU_STREAM_WRITE_VALUE_DEFAULT' in found_values}}
 
     #: Default behavior
-    CU_STREAM_WRITE_VALUE_DEFAULT = ccuda.CUstreamWriteValue_flags_enum.CU_STREAM_WRITE_VALUE_DEFAULT{{endif}}
+    CU_STREAM_WRITE_VALUE_DEFAULT = cydriver.CUstreamWriteValue_flags_enum.CU_STREAM_WRITE_VALUE_DEFAULT{{endif}}
     {{if 'CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER' in found_values}}
 
     #: Permits the write to be reordered with writes which were issued
@@ -558,7 +559,7 @@ class CUstreamWriteValue_flags(IntEnum):
     #: the write, which has similar semantics to __threadfence_system() but
     #: is scoped to the stream rather than a CUDA thread. This flag is not
     #: supported in the v2 API.
-    CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = ccuda.CUstreamWriteValue_flags_enum.CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER{{endif}}
+    CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER = cydriver.CUstreamWriteValue_flags_enum.CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER{{endif}}
 {{endif}}
 {{if 'CUstreamBatchMemOpType_enum' in found_types}}
 
@@ -569,28 +570,28 @@ class CUstreamBatchMemOpType(IntEnum):
     {{if 'CU_STREAM_MEM_OP_WAIT_VALUE_32' in found_values}}
 
     #: Represents a :py:obj:`~.cuStreamWaitValue32` operation
-    CU_STREAM_MEM_OP_WAIT_VALUE_32 = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WAIT_VALUE_32{{endif}}
+    CU_STREAM_MEM_OP_WAIT_VALUE_32 = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WAIT_VALUE_32{{endif}}
     {{if 'CU_STREAM_MEM_OP_WRITE_VALUE_32' in found_values}}
 
     #: Represents a :py:obj:`~.cuStreamWriteValue32` operation
-    CU_STREAM_MEM_OP_WRITE_VALUE_32 = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WRITE_VALUE_32{{endif}}
+    CU_STREAM_MEM_OP_WRITE_VALUE_32 = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WRITE_VALUE_32{{endif}}
+    {{if 'CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES' in found_values}}
+
+    #: This has the same effect as :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH`,
+    #: but as a standalone operation.
+    CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES{{endif}}
     {{if 'CU_STREAM_MEM_OP_WAIT_VALUE_64' in found_values}}
 
     #: Represents a :py:obj:`~.cuStreamWaitValue64` operation
-    CU_STREAM_MEM_OP_WAIT_VALUE_64 = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WAIT_VALUE_64{{endif}}
+    CU_STREAM_MEM_OP_WAIT_VALUE_64 = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WAIT_VALUE_64{{endif}}
     {{if 'CU_STREAM_MEM_OP_WRITE_VALUE_64' in found_values}}
 
     #: Represents a :py:obj:`~.cuStreamWriteValue64` operation
-    CU_STREAM_MEM_OP_WRITE_VALUE_64 = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WRITE_VALUE_64{{endif}}
+    CU_STREAM_MEM_OP_WRITE_VALUE_64 = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_WRITE_VALUE_64{{endif}}
     {{if 'CU_STREAM_MEM_OP_BARRIER' in found_values}}
 
     #: Insert a memory barrier of the specified type
-    CU_STREAM_MEM_OP_BARRIER = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_BARRIER{{endif}}
-    {{if 'CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES' in found_values}}
-
-    #: This has the same effect as :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH`,
-    #: but as a standalone operation.
-    CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES = ccuda.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES{{endif}}
+    CU_STREAM_MEM_OP_BARRIER = cydriver.CUstreamBatchMemOpType_enum.CU_STREAM_MEM_OP_BARRIER{{endif}}
 {{endif}}
 {{if 'CUstreamMemoryBarrier_flags_enum' in found_types}}
 
@@ -601,11 +602,11 @@ class CUstreamMemoryBarrier_flags(IntEnum):
     {{if 'CU_STREAM_MEMORY_BARRIER_TYPE_SYS' in found_values}}
 
     #: System-wide memory barrier.
-    CU_STREAM_MEMORY_BARRIER_TYPE_SYS = ccuda.CUstreamMemoryBarrier_flags_enum.CU_STREAM_MEMORY_BARRIER_TYPE_SYS{{endif}}
+    CU_STREAM_MEMORY_BARRIER_TYPE_SYS = cydriver.CUstreamMemoryBarrier_flags_enum.CU_STREAM_MEMORY_BARRIER_TYPE_SYS{{endif}}
     {{if 'CU_STREAM_MEMORY_BARRIER_TYPE_GPU' in found_values}}
 
     #: Limit memory barrier scope to the GPU.
-    CU_STREAM_MEMORY_BARRIER_TYPE_GPU = ccuda.CUstreamMemoryBarrier_flags_enum.CU_STREAM_MEMORY_BARRIER_TYPE_GPU{{endif}}
+    CU_STREAM_MEMORY_BARRIER_TYPE_GPU = cydriver.CUstreamMemoryBarrier_flags_enum.CU_STREAM_MEMORY_BARRIER_TYPE_GPU{{endif}}
 {{endif}}
 {{if 'CUoccupancy_flags_enum' in found_types}}
 
@@ -616,12 +617,12 @@ class CUoccupancy_flags(IntEnum):
     {{if 'CU_OCCUPANCY_DEFAULT' in found_values}}
 
     #: Default behavior
-    CU_OCCUPANCY_DEFAULT = ccuda.CUoccupancy_flags_enum.CU_OCCUPANCY_DEFAULT{{endif}}
+    CU_OCCUPANCY_DEFAULT = cydriver.CUoccupancy_flags_enum.CU_OCCUPANCY_DEFAULT{{endif}}
     {{if 'CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE' in found_values}}
 
     #: Assume global caching is enabled and cannot be automatically turned
     #: off
-    CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = ccuda.CUoccupancy_flags_enum.CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE{{endif}}
+    CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE = cydriver.CUoccupancy_flags_enum.CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE{{endif}}
 {{endif}}
 {{if 'CUstreamUpdateCaptureDependencies_flags_enum' in found_types}}
 
@@ -632,11 +633,11 @@ class CUstreamUpdateCaptureDependencies_flags(IntEnum):
     {{if 'CU_STREAM_ADD_CAPTURE_DEPENDENCIES' in found_values}}
 
     #: Add new nodes to the dependency set
-    CU_STREAM_ADD_CAPTURE_DEPENDENCIES = ccuda.CUstreamUpdateCaptureDependencies_flags_enum.CU_STREAM_ADD_CAPTURE_DEPENDENCIES{{endif}}
+    CU_STREAM_ADD_CAPTURE_DEPENDENCIES = cydriver.CUstreamUpdateCaptureDependencies_flags_enum.CU_STREAM_ADD_CAPTURE_DEPENDENCIES{{endif}}
     {{if 'CU_STREAM_SET_CAPTURE_DEPENDENCIES' in found_values}}
 
     #: Replace the dependency set with the new nodes
-    CU_STREAM_SET_CAPTURE_DEPENDENCIES = ccuda.CUstreamUpdateCaptureDependencies_flags_enum.CU_STREAM_SET_CAPTURE_DEPENDENCIES{{endif}}
+    CU_STREAM_SET_CAPTURE_DEPENDENCIES = cydriver.CUstreamUpdateCaptureDependencies_flags_enum.CU_STREAM_SET_CAPTURE_DEPENDENCIES{{endif}}
 {{endif}}
 {{if 'CUarray_format_enum' in found_types}}
 
@@ -647,157 +648,157 @@ class CUarray_format(IntEnum):
     {{if 'CU_AD_FORMAT_UNSIGNED_INT8' in found_values}}
 
     #: Unsigned 8-bit integers
-    CU_AD_FORMAT_UNSIGNED_INT8 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8{{endif}}
+    CU_AD_FORMAT_UNSIGNED_INT8 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT8{{endif}}
     {{if 'CU_AD_FORMAT_UNSIGNED_INT16' in found_values}}
 
     #: Unsigned 16-bit integers
-    CU_AD_FORMAT_UNSIGNED_INT16 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16{{endif}}
+    CU_AD_FORMAT_UNSIGNED_INT16 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT16{{endif}}
     {{if 'CU_AD_FORMAT_UNSIGNED_INT32' in found_values}}
 
     #: Unsigned 32-bit integers
-    CU_AD_FORMAT_UNSIGNED_INT32 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32{{endif}}
+    CU_AD_FORMAT_UNSIGNED_INT32 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNSIGNED_INT32{{endif}}
     {{if 'CU_AD_FORMAT_SIGNED_INT8' in found_values}}
 
     #: Signed 8-bit integers
-    CU_AD_FORMAT_SIGNED_INT8 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8{{endif}}
+    CU_AD_FORMAT_SIGNED_INT8 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT8{{endif}}
     {{if 'CU_AD_FORMAT_SIGNED_INT16' in found_values}}
 
     #: Signed 16-bit integers
-    CU_AD_FORMAT_SIGNED_INT16 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16{{endif}}
+    CU_AD_FORMAT_SIGNED_INT16 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT16{{endif}}
     {{if 'CU_AD_FORMAT_SIGNED_INT32' in found_values}}
 
     #: Signed 32-bit integers
-    CU_AD_FORMAT_SIGNED_INT32 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32{{endif}}
+    CU_AD_FORMAT_SIGNED_INT32 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SIGNED_INT32{{endif}}
     {{if 'CU_AD_FORMAT_HALF' in found_values}}
 
     #: 16-bit floating point
-    CU_AD_FORMAT_HALF = ccuda.CUarray_format_enum.CU_AD_FORMAT_HALF{{endif}}
+    CU_AD_FORMAT_HALF = cydriver.CUarray_format_enum.CU_AD_FORMAT_HALF{{endif}}
     {{if 'CU_AD_FORMAT_FLOAT' in found_values}}
 
     #: 32-bit floating point
-    CU_AD_FORMAT_FLOAT = ccuda.CUarray_format_enum.CU_AD_FORMAT_FLOAT{{endif}}
-    {{if 'CU_AD_FORMAT_NV12' in found_values}}
-
-    #: 8-bit YUV planar format, with 4:2:0 sampling
-    CU_AD_FORMAT_NV12 = ccuda.CUarray_format_enum.CU_AD_FORMAT_NV12{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT8X1' in found_values}}
-
-    #: 1 channel unsigned 8-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT8X1 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X1{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT8X2' in found_values}}
-
-    #: 2 channel unsigned 8-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT8X2 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X2{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT8X4' in found_values}}
-
-    #: 4 channel unsigned 8-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT8X4 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X4{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT16X1' in found_values}}
-
-    #: 1 channel unsigned 16-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT16X1 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X1{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT16X2' in found_values}}
-
-    #: 2 channel unsigned 16-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT16X2 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X2{{endif}}
-    {{if 'CU_AD_FORMAT_UNORM_INT16X4' in found_values}}
-
-    #: 4 channel unsigned 16-bit normalized integer
-    CU_AD_FORMAT_UNORM_INT16X4 = ccuda.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X4{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT8X1' in found_values}}
-
-    #: 1 channel signed 8-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT8X1 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X1{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT8X2' in found_values}}
-
-    #: 2 channel signed 8-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT8X2 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X2{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT8X4' in found_values}}
-
-    #: 4 channel signed 8-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT8X4 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X4{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT16X1' in found_values}}
-
-    #: 1 channel signed 16-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT16X1 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X1{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT16X2' in found_values}}
-
-    #: 2 channel signed 16-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT16X2 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X2{{endif}}
-    {{if 'CU_AD_FORMAT_SNORM_INT16X4' in found_values}}
-
-    #: 4 channel signed 16-bit normalized integer
-    CU_AD_FORMAT_SNORM_INT16X4 = ccuda.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X4{{endif}}
+    CU_AD_FORMAT_FLOAT = cydriver.CUarray_format_enum.CU_AD_FORMAT_FLOAT{{endif}}
     {{if 'CU_AD_FORMAT_BC1_UNORM' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC1 compression)
     #: format
-    CU_AD_FORMAT_BC1_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM{{endif}}
+    CU_AD_FORMAT_BC1_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC1_UNORM_SRGB' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC1 compression)
     #: format with sRGB encoding
-    CU_AD_FORMAT_BC1_UNORM_SRGB = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM_SRGB{{endif}}
+    CU_AD_FORMAT_BC1_UNORM_SRGB = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC1_UNORM_SRGB{{endif}}
     {{if 'CU_AD_FORMAT_BC2_UNORM' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC2 compression)
     #: format
-    CU_AD_FORMAT_BC2_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM{{endif}}
+    CU_AD_FORMAT_BC2_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC2_UNORM_SRGB' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC2 compression)
     #: format with sRGB encoding
-    CU_AD_FORMAT_BC2_UNORM_SRGB = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM_SRGB{{endif}}
+    CU_AD_FORMAT_BC2_UNORM_SRGB = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC2_UNORM_SRGB{{endif}}
     {{if 'CU_AD_FORMAT_BC3_UNORM' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC3 compression)
     #: format
-    CU_AD_FORMAT_BC3_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM{{endif}}
+    CU_AD_FORMAT_BC3_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC3_UNORM_SRGB' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC3 compression)
     #: format with sRGB encoding
-    CU_AD_FORMAT_BC3_UNORM_SRGB = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM_SRGB{{endif}}
+    CU_AD_FORMAT_BC3_UNORM_SRGB = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC3_UNORM_SRGB{{endif}}
     {{if 'CU_AD_FORMAT_BC4_UNORM' in found_values}}
 
     #: 1 channel unsigned normalized block-compressed (BC4 compression)
     #: format
-    CU_AD_FORMAT_BC4_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC4_UNORM{{endif}}
+    CU_AD_FORMAT_BC4_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC4_SNORM' in found_values}}
 
     #: 1 channel signed normalized block-compressed (BC4 compression)
     #: format
-    CU_AD_FORMAT_BC4_SNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC4_SNORM{{endif}}
+    CU_AD_FORMAT_BC4_SNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC4_SNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC5_UNORM' in found_values}}
 
     #: 2 channel unsigned normalized block-compressed (BC5 compression)
     #: format
-    CU_AD_FORMAT_BC5_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC5_UNORM{{endif}}
+    CU_AD_FORMAT_BC5_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC5_SNORM' in found_values}}
 
     #: 2 channel signed normalized block-compressed (BC5 compression)
     #: format
-    CU_AD_FORMAT_BC5_SNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC5_SNORM{{endif}}
+    CU_AD_FORMAT_BC5_SNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC5_SNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC6H_UF16' in found_values}}
 
     #: 3 channel unsigned half-float block-compressed (BC6H compression)
     #: format
-    CU_AD_FORMAT_BC6H_UF16 = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC6H_UF16{{endif}}
+    CU_AD_FORMAT_BC6H_UF16 = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_UF16{{endif}}
     {{if 'CU_AD_FORMAT_BC6H_SF16' in found_values}}
 
     #: 3 channel signed half-float block-compressed (BC6H compression)
     #: format
-    CU_AD_FORMAT_BC6H_SF16 = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC6H_SF16{{endif}}
+    CU_AD_FORMAT_BC6H_SF16 = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC6H_SF16{{endif}}
     {{if 'CU_AD_FORMAT_BC7_UNORM' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC7 compression)
     #: format
-    CU_AD_FORMAT_BC7_UNORM = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM{{endif}}
+    CU_AD_FORMAT_BC7_UNORM = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM{{endif}}
     {{if 'CU_AD_FORMAT_BC7_UNORM_SRGB' in found_values}}
 
     #: 4 channel unsigned normalized block-compressed (BC7 compression)
     #: format with sRGB encoding
-    CU_AD_FORMAT_BC7_UNORM_SRGB = ccuda.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM_SRGB{{endif}}
+    CU_AD_FORMAT_BC7_UNORM_SRGB = cydriver.CUarray_format_enum.CU_AD_FORMAT_BC7_UNORM_SRGB{{endif}}
+    {{if 'CU_AD_FORMAT_NV12' in found_values}}
+
+    #: 8-bit YUV planar format, with 4:2:0 sampling
+    CU_AD_FORMAT_NV12 = cydriver.CUarray_format_enum.CU_AD_FORMAT_NV12{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT8X1' in found_values}}
+
+    #: 1 channel unsigned 8-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT8X1 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X1{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT8X2' in found_values}}
+
+    #: 2 channel unsigned 8-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT8X2 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X2{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT8X4' in found_values}}
+
+    #: 4 channel unsigned 8-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT8X4 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT8X4{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT16X1' in found_values}}
+
+    #: 1 channel unsigned 16-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT16X1 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X1{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT16X2' in found_values}}
+
+    #: 2 channel unsigned 16-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT16X2 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X2{{endif}}
+    {{if 'CU_AD_FORMAT_UNORM_INT16X4' in found_values}}
+
+    #: 4 channel unsigned 16-bit normalized integer
+    CU_AD_FORMAT_UNORM_INT16X4 = cydriver.CUarray_format_enum.CU_AD_FORMAT_UNORM_INT16X4{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT8X1' in found_values}}
+
+    #: 1 channel signed 8-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT8X1 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X1{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT8X2' in found_values}}
+
+    #: 2 channel signed 8-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT8X2 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X2{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT8X4' in found_values}}
+
+    #: 4 channel signed 8-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT8X4 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT8X4{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT16X1' in found_values}}
+
+    #: 1 channel signed 16-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT16X1 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X1{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT16X2' in found_values}}
+
+    #: 2 channel signed 16-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT16X2 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X2{{endif}}
+    {{if 'CU_AD_FORMAT_SNORM_INT16X4' in found_values}}
+
+    #: 4 channel signed 16-bit normalized integer
+    CU_AD_FORMAT_SNORM_INT16X4 = cydriver.CUarray_format_enum.CU_AD_FORMAT_SNORM_INT16X4{{endif}}
 {{endif}}
 {{if 'CUaddress_mode_enum' in found_types}}
 
@@ -808,19 +809,19 @@ class CUaddress_mode(IntEnum):
     {{if 'CU_TR_ADDRESS_MODE_WRAP' in found_values}}
 
     #: Wrapping address mode
-    CU_TR_ADDRESS_MODE_WRAP = ccuda.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_WRAP{{endif}}
+    CU_TR_ADDRESS_MODE_WRAP = cydriver.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_WRAP{{endif}}
     {{if 'CU_TR_ADDRESS_MODE_CLAMP' in found_values}}
 
     #: Clamp to edge address mode
-    CU_TR_ADDRESS_MODE_CLAMP = ccuda.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_CLAMP{{endif}}
+    CU_TR_ADDRESS_MODE_CLAMP = cydriver.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_CLAMP{{endif}}
     {{if 'CU_TR_ADDRESS_MODE_MIRROR' in found_values}}
 
     #: Mirror address mode
-    CU_TR_ADDRESS_MODE_MIRROR = ccuda.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_MIRROR{{endif}}
+    CU_TR_ADDRESS_MODE_MIRROR = cydriver.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_MIRROR{{endif}}
     {{if 'CU_TR_ADDRESS_MODE_BORDER' in found_values}}
 
     #: Border address mode
-    CU_TR_ADDRESS_MODE_BORDER = ccuda.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_BORDER{{endif}}
+    CU_TR_ADDRESS_MODE_BORDER = cydriver.CUaddress_mode_enum.CU_TR_ADDRESS_MODE_BORDER{{endif}}
 {{endif}}
 {{if 'CUfilter_mode_enum' in found_types}}
 
@@ -831,11 +832,11 @@ class CUfilter_mode(IntEnum):
     {{if 'CU_TR_FILTER_MODE_POINT' in found_values}}
 
     #: Point filter mode
-    CU_TR_FILTER_MODE_POINT = ccuda.CUfilter_mode_enum.CU_TR_FILTER_MODE_POINT{{endif}}
+    CU_TR_FILTER_MODE_POINT = cydriver.CUfilter_mode_enum.CU_TR_FILTER_MODE_POINT{{endif}}
     {{if 'CU_TR_FILTER_MODE_LINEAR' in found_values}}
 
     #: Linear filter mode
-    CU_TR_FILTER_MODE_LINEAR = ccuda.CUfilter_mode_enum.CU_TR_FILTER_MODE_LINEAR{{endif}}
+    CU_TR_FILTER_MODE_LINEAR = cydriver.CUfilter_mode_enum.CU_TR_FILTER_MODE_LINEAR{{endif}}
 {{endif}}
 {{if 'CUdevice_attribute_enum' in found_types}}
 
@@ -846,563 +847,563 @@ class CUdevice_attribute(IntEnum):
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK' in found_values}}
 
     #: Maximum number of threads per block
-    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X' in found_values}}
 
     #: Maximum block dimension X
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y' in found_values}}
 
     #: Maximum block dimension Y
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z' in found_values}}
 
     #: Maximum block dimension Z
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X' in found_values}}
 
     #: Maximum grid dimension X
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y' in found_values}}
 
     #: Maximum grid dimension Y
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z' in found_values}}
 
     #: Maximum grid dimension Z
-    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK' in found_values}}
 
     #: Maximum shared memory available per block in bytes
-    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK' in found_values}}
 
     #: Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
-    CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY' in found_values}}
 
     #: Memory available on device for constant variables in a CUDA C kernel
     #: in bytes
-    CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY{{endif}}
+    CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_WARP_SIZE' in found_values}}
 
     #: Warp size in threads
-    CU_DEVICE_ATTRIBUTE_WARP_SIZE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_WARP_SIZE{{endif}}
+    CU_DEVICE_ATTRIBUTE_WARP_SIZE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_WARP_SIZE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_PITCH' in found_values}}
 
     #: Maximum pitch in bytes allowed by memory copies
-    CU_DEVICE_ATTRIBUTE_MAX_PITCH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_PITCH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_PITCH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_PITCH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK' in found_values}}
 
     #: Maximum number of 32-bit registers available per block
-    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK' in found_values}}
 
     #: Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK
-    CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CLOCK_RATE' in found_values}}
 
     #: Typical clock frequency in kilohertz
-    CU_DEVICE_ATTRIBUTE_CLOCK_RATE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CLOCK_RATE{{endif}}
+    CU_DEVICE_ATTRIBUTE_CLOCK_RATE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CLOCK_RATE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT' in found_values}}
 
     #: Alignment requirement for textures
-    CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT{{endif}}
+    CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GPU_OVERLAP' in found_values}}
 
     #: Device can possibly copy memory and execute a kernel concurrently.
     #: Deprecated. Use instead CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT.
-    CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_OVERLAP{{endif}}
+    CU_DEVICE_ATTRIBUTE_GPU_OVERLAP = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_OVERLAP{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT' in found_values}}
 
     #: Number of multiprocessors on device
-    CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT' in found_values}}
 
     #: Specifies whether there is a run time limit on kernels
-    CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT{{endif}}
+    CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_INTEGRATED' in found_values}}
 
     #: Device is integrated with host memory
-    CU_DEVICE_ATTRIBUTE_INTEGRATED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_INTEGRATED{{endif}}
+    CU_DEVICE_ATTRIBUTE_INTEGRATED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_INTEGRATED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY' in found_values}}
 
     #: Device can map host memory into CUDA address space
-    CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COMPUTE_MODE' in found_values}}
 
     #: Compute mode (See :py:obj:`~.CUcomputemode` for details)
-    CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_MODE{{endif}}
+    CU_DEVICE_ATTRIBUTE_COMPUTE_MODE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_MODE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH' in found_values}}
 
     #: Maximum 1D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH' in found_values}}
 
     #: Maximum 2D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT' in found_values}}
 
     #: Maximum 2D texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH' in found_values}}
 
     #: Maximum 3D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT' in found_values}}
 
     #: Maximum 3D texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH' in found_values}}
 
     #: Maximum 3D texture depth
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH' in found_values}}
 
     #: Maximum 2D layered texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH{{endif}}
-    {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT' in found_values}}
-
-    #: Maximum 2D layered texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT{{endif}}
-    {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS' in found_values}}
-
-    #: Maximum layers in a 2D layered texture
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH' in found_values}}
 
     #: Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH{{endif}}
+    {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT' in found_values}}
+
+    #: Maximum 2D layered texture height
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT' in found_values}}
 
     #: Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT{{endif}}
+    {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS' in found_values}}
+
+    #: Maximum layers in a 2D layered texture
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES' in found_values}}
 
     #: Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT' in found_values}}
 
     #: Alignment requirement for surfaces
-    CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT{{endif}}
+    CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS' in found_values}}
 
     #: Device can possibly execute multiple kernels concurrently
-    CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS{{endif}}
+    CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_ECC_ENABLED' in found_values}}
 
     #: Device has ECC support enabled
-    CU_DEVICE_ATTRIBUTE_ECC_ENABLED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_ECC_ENABLED{{endif}}
+    CU_DEVICE_ATTRIBUTE_ECC_ENABLED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_ECC_ENABLED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_PCI_BUS_ID' in found_values}}
 
     #: PCI bus ID of the device
-    CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_BUS_ID{{endif}}
+    CU_DEVICE_ATTRIBUTE_PCI_BUS_ID = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_BUS_ID{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID' in found_values}}
 
     #: PCI device ID of the device
-    CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID{{endif}}
+    CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_TCC_DRIVER' in found_values}}
 
     #: Device is using TCC driver model
-    CU_DEVICE_ATTRIBUTE_TCC_DRIVER = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TCC_DRIVER{{endif}}
+    CU_DEVICE_ATTRIBUTE_TCC_DRIVER = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TCC_DRIVER{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE' in found_values}}
 
     #: Peak memory clock frequency in kilohertz
-    CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH' in found_values}}
 
     #: Global memory bus width in bits
-    CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE' in found_values}}
 
     #: Size of L2 cache in bytes
-    CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE{{endif}}
+    CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR' in found_values}}
 
     #: Maximum resident threads per multiprocessor
-    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT' in found_values}}
 
     #: Number of asynchronous engines
-    CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT{{endif}}
+    CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING' in found_values}}
 
     #: Device shares a unified address space with the host
-    CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING{{endif}}
+    CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH' in found_values}}
 
     #: Maximum 1D layered texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS' in found_values}}
 
     #: Maximum layers in a 1D layered texture
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER' in found_values}}
 
     #: Deprecated, do not use.
-    CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH' in found_values}}
 
     #: Maximum 2D texture width if CUDA_ARRAY3D_TEXTURE_GATHER is set
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT' in found_values}}
 
     #: Maximum 2D texture height if CUDA_ARRAY3D_TEXTURE_GATHER is set
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE' in found_values}}
 
     #: Alternate maximum 3D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE' in found_values}}
 
     #: Alternate maximum 3D texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE' in found_values}}
 
     #: Alternate maximum 3D texture depth
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID' in found_values}}
 
     #: PCI domain ID of the device
-    CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID{{endif}}
+    CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT' in found_values}}
 
     #: Pitch alignment requirement for textures
-    CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT{{endif}}
+    CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH' in found_values}}
 
     #: Maximum cubemap texture width/height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH' in found_values}}
 
     #: Maximum cubemap layered texture width/height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS' in found_values}}
 
     #: Maximum layers in a cubemap layered texture
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH' in found_values}}
 
     #: Maximum 1D surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH' in found_values}}
 
     #: Maximum 2D surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT' in found_values}}
 
     #: Maximum 2D surface height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH' in found_values}}
 
     #: Maximum 3D surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT' in found_values}}
 
     #: Maximum 3D surface height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH' in found_values}}
 
     #: Maximum 3D surface depth
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH' in found_values}}
 
     #: Maximum 1D layered surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS' in found_values}}
 
     #: Maximum layers in a 1D layered surface
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH' in found_values}}
 
     #: Maximum 2D layered surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT' in found_values}}
 
     #: Maximum 2D layered surface height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS' in found_values}}
 
     #: Maximum layers in a 2D layered surface
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH' in found_values}}
 
     #: Maximum cubemap surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH' in found_values}}
 
     #: Maximum cubemap layered surface width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS' in found_values}}
 
     #: Maximum layers in a cubemap layered surface
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH' in found_values}}
 
     #: Deprecated, do not use. Use cudaDeviceGetTexture1DLinearMaxWidth()
     #: or :py:obj:`~.cuDeviceGetTexture1DLinearMaxWidth()` instead.
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH' in found_values}}
 
     #: Maximum 2D linear texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT' in found_values}}
 
     #: Maximum 2D linear texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH' in found_values}}
 
     #: Maximum 2D linear texture pitch in bytes
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH' in found_values}}
 
     #: Maximum mipmapped 2D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT' in found_values}}
 
     #: Maximum mipmapped 2D texture height
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR' in found_values}}
 
     #: Major compute capability version number
-    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR' in found_values}}
 
     #: Minor compute capability version number
-    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH' in found_values}}
 
     #: Maximum mipmapped 1D texture width
-    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED' in found_values}}
 
     #: Device supports stream priorities
-    CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED' in found_values}}
 
     #: Device supports caching globals in L1
-    CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED' in found_values}}
 
     #: Device supports caching locals in L1
-    CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR' in found_values}}
 
     #: Maximum shared memory available per multiprocessor in bytes
-    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR' in found_values}}
 
     #: Maximum number of 32-bit registers available per multiprocessor
-    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY' in found_values}}
 
     #: Device can allocate managed memory on this system
-    CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY{{endif}}
+    CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD' in found_values}}
 
     #: Device is on a multi-GPU board
-    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD{{endif}}
+    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID' in found_values}}
 
     #: Unique id for a group of devices on the same multi-GPU board
-    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID{{endif}}
+    CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED' in found_values}}
 
     #: Link between the device and the host supports native atomic
     #: operations (this is a placeholder attribute, and is not supported on
     #: any current hardware)
-    CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO' in found_values}}
 
     #: Ratio of single precision performance (in floating-point operations
     #: per second) to double precision performance
-    CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO{{endif}}
+    CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS' in found_values}}
 
     #: Device supports coherently accessing pageable memory without calling
     #: cudaHostRegister on it
-    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS{{endif}}
+    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS' in found_values}}
 
     #: Device can coherently access managed memory concurrently with the
     #: CPU
-    CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS{{endif}}
+    CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED' in found_values}}
 
     #: Device supports compute preemption.
-    CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM' in found_values}}
 
     #: Device can access host registered memory at the same virtual address
     #: as the CPU
-    CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS' in found_values}}
 
     #: :py:obj:`~.cuStreamBatchMemOp` and related APIs are supported.
-    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS' in found_values}}
 
     #: 64-bit operations are supported in :py:obj:`~.cuStreamBatchMemOp`
     #: and related APIs.
-    CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR' in found_values}}
 
     #: :py:obj:`~.CU_STREAM_WAIT_VALUE_NOR` is supported.
-    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH' in found_values}}
 
     #: Device supports launching cooperative kernels via
     #: :py:obj:`~.cuLaunchCooperativeKernel`
-    CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH{{endif}}
+    CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH' in found_values}}
 
     #: Deprecated, :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` is
     #: deprecated.
-    CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH{{endif}}
+    CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN' in found_values}}
 
     #: Maximum optin shared memory per block
-    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES' in found_values}}
 
     #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the
     #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
     #: on the device. See :py:obj:`~.Stream Memory Operations` for
     #: additional details.
-    CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED' in found_values}}
 
     #: Device supports host memory registration via
     #: :py:obj:`~.cudaHostRegister`.
-    CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES' in found_values}}
 
     #: Device accesses pageable memory via the host's page tables.
-    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES{{endif}}
+    CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST' in found_values}}
 
     #: The host can directly access managed memory on the device without
     #: migration.
-    CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST{{endif}}
+    CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED' in found_values}}
 
     #: Deprecated, Use
     #: CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED
-    CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED' in found_values}}
 
     #: Device supports virtual memory management APIs like
     #: :py:obj:`~.cuMemAddressReserve`, :py:obj:`~.cuMemCreate`,
     #: :py:obj:`~.cuMemMap` and related APIs
-    CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED' in found_values}}
 
     #: Device supports exporting memory to a posix file descriptor with
     #: :py:obj:`~.cuMemExportToShareableHandle`, if requested via
     #: :py:obj:`~.cuMemCreate`
-    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED' in found_values}}
 
     #: Device supports exporting memory to a Win32 NT handle with
     #: :py:obj:`~.cuMemExportToShareableHandle`, if requested via
     #: :py:obj:`~.cuMemCreate`
-    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED' in found_values}}
 
     #: Device supports exporting memory to a Win32 KMT handle with
     #: :py:obj:`~.cuMemExportToShareableHandle`, if requested via
     #: :py:obj:`~.cuMemCreate`
-    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR' in found_values}}
 
     #: Maximum number of blocks per multiprocessor
-    CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED' in found_values}}
 
     #: Device supports compression of memory
-    CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE' in found_values}}
 
     #: Maximum L2 persisting lines capacity setting in bytes.
-    CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE' in found_values}}
 
     #: Maximum value of :py:obj:`~.CUaccessPolicyWindow.num_bytes`.
-    CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED' in found_values}}
 
     #: Device supports specifying the GPUDirect RDMA flag with
     #: :py:obj:`~.cuMemCreate`
-    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK' in found_values}}
 
     #: Shared memory reserved by CUDA driver per block in bytes
-    CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK{{endif}}
+    CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED' in found_values}}
 
     #: Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays
-    CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED' in found_values}}
 
     #: Device supports using the :py:obj:`~.cuMemHostRegister` flag
     #: :py:obj:`~.CU_MEMHOSTERGISTER_READ_ONLY` to register memory that
     #: must be mapped as read-only to the GPU
-    CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED' in found_values}}
 
     #: External timeline semaphore interop is supported on the device
-    CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED' in found_values}}
 
     #: Device supports using the :py:obj:`~.cuMemAllocAsync` and
     #: :py:obj:`~.cuMemPool` family of APIs
-    CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED' in found_values}}
 
     #: Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see
     #: https://docs.nvidia.com/cuda/gpudirect-rdma for more information)
-    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS' in found_values}}
 
     #: The returned attribute shall be interpreted as a bitmask, where the
     #: individual bits are described by the
     #: :py:obj:`~.CUflushGPUDirectRDMAWritesOptions` enum
-    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS{{endif}}
+    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING' in found_values}}
 
     #: GPUDirect RDMA writes to the device do not need to be flushed for
     #: consumers within the scope indicated by the returned attribute. See
     #: :py:obj:`~.CUGPUDirectRDMAWritesOrdering` for the numerical values
     #: returned here.
-    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING{{endif}}
+    CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES' in found_values}}
 
     #: Handle types supported with mempool based IPC
-    CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES{{endif}}
+    CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH' in found_values}}
 
     #: Indicates device supports cluster launch
-    CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH{{endif}}
+    CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED' in found_values}}
 
     #: Device supports deferred mapping CUDA arrays and CUDA mipmapped
     #: arrays
-    CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2' in found_values}}
 
     #: 64-bit operations are supported in :py:obj:`~.cuStreamBatchMemOp_v2`
     #: and related v2 MemOp APIs.
-    CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2 = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2 = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2' in found_values}}
 
     #: :py:obj:`~.CU_STREAM_WAIT_VALUE_NOR` is supported by v2 MemOp APIs.
-    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2 = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2{{endif}}
+    CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2 = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED' in found_values}}
 
     #: Device supports buffer sharing with dma_buf mechanism.
-    CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED{{endif}}
+    CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_ATTRIBUTE_MAX' in found_values}}
-    CU_DEVICE_ATTRIBUTE_MAX = ccuda.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX{{endif}}
+    CU_DEVICE_ATTRIBUTE_MAX = cydriver.CUdevice_attribute_enum.CU_DEVICE_ATTRIBUTE_MAX{{endif}}
 {{endif}}
 {{if 'CUpointer_attribute_enum' in found_types}}
 
@@ -1414,95 +1415,95 @@ class CUpointer_attribute(IntEnum):
 
     #: The :py:obj:`~.CUcontext` on which a pointer was allocated or
     #: registered
-    CU_POINTER_ATTRIBUTE_CONTEXT = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT{{endif}}
+    CU_POINTER_ATTRIBUTE_CONTEXT = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_CONTEXT{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MEMORY_TYPE' in found_values}}
 
     #: The :py:obj:`~.CUmemorytype` describing the physical location of a
     #: pointer
-    CU_POINTER_ATTRIBUTE_MEMORY_TYPE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE{{endif}}
+    CU_POINTER_ATTRIBUTE_MEMORY_TYPE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_TYPE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_DEVICE_POINTER' in found_values}}
 
     #: The address at which a pointer's memory may be accessed on the
     #: device
-    CU_POINTER_ATTRIBUTE_DEVICE_POINTER = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER{{endif}}
+    CU_POINTER_ATTRIBUTE_DEVICE_POINTER = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_POINTER{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_HOST_POINTER' in found_values}}
 
     #: The address at which a pointer's memory may be accessed on the host
-    CU_POINTER_ATTRIBUTE_HOST_POINTER = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER{{endif}}
+    CU_POINTER_ATTRIBUTE_HOST_POINTER = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_HOST_POINTER{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_P2P_TOKENS' in found_values}}
 
     #: A pair of tokens for use with the nv-p2p.h Linux kernel interface
-    CU_POINTER_ATTRIBUTE_P2P_TOKENS = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS{{endif}}
+    CU_POINTER_ATTRIBUTE_P2P_TOKENS = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_P2P_TOKENS{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_SYNC_MEMOPS' in found_values}}
 
     #: Synchronize every synchronous memory operation initiated on this
     #: region
-    CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS{{endif}}
+    CU_POINTER_ATTRIBUTE_SYNC_MEMOPS = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_BUFFER_ID' in found_values}}
 
     #: A process-wide unique ID for an allocated memory region
-    CU_POINTER_ATTRIBUTE_BUFFER_ID = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID{{endif}}
+    CU_POINTER_ATTRIBUTE_BUFFER_ID = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_BUFFER_ID{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_IS_MANAGED' in found_values}}
 
     #: Indicates if the pointer points to managed memory
-    CU_POINTER_ATTRIBUTE_IS_MANAGED = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED{{endif}}
+    CU_POINTER_ATTRIBUTE_IS_MANAGED = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_MANAGED{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL' in found_values}}
 
     #: A device ordinal of a device on which a pointer was allocated or
     #: registered
-    CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL{{endif}}
+    CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE' in found_values}}
 
     #: 1 if this pointer maps to an allocation that is suitable for
     #: :py:obj:`~.cudaIpcGetMemHandle`, 0 otherwise
-    CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE{{endif}}
+    CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_RANGE_START_ADDR' in found_values}}
 
     #: Starting address for this requested pointer
-    CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR{{endif}}
+    CU_POINTER_ATTRIBUTE_RANGE_START_ADDR = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_RANGE_SIZE' in found_values}}
 
     #: Size of the address range for this requested pointer
-    CU_POINTER_ATTRIBUTE_RANGE_SIZE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE{{endif}}
+    CU_POINTER_ATTRIBUTE_RANGE_SIZE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_RANGE_SIZE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MAPPED' in found_values}}
 
     #: 1 if this pointer is in a valid address range that is mapped to a
     #: backing allocation, 0 otherwise
-    CU_POINTER_ATTRIBUTE_MAPPED = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED{{endif}}
+    CU_POINTER_ATTRIBUTE_MAPPED = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPED{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES' in found_values}}
 
     #: Bitmask of allowed :py:obj:`~.CUmemAllocationHandleType` for this
     #: allocation
-    CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES{{endif}}
+    CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE' in found_values}}
 
     #: 1 if the memory this pointer is referencing can be used with the
     #: GPUDirect RDMA API
-    CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE{{endif}}
+    CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAGS' in found_values}}
 
     #: Returns the access flags the device associated with the current
     #: context has on the corresponding memory referenced by the pointer
     #: given
-    CU_POINTER_ATTRIBUTE_ACCESS_FLAGS = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS{{endif}}
+    CU_POINTER_ATTRIBUTE_ACCESS_FLAGS = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE' in found_values}}
 
     #: Returns the mempool handle for the allocation if it was allocated
     #: from a mempool. Otherwise returns NULL.
-    CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE{{endif}}
+    CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MAPPING_SIZE' in found_values}}
 
     #: Size of the actual underlying mapping that the pointer belongs to
-    CU_POINTER_ATTRIBUTE_MAPPING_SIZE = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPING_SIZE{{endif}}
+    CU_POINTER_ATTRIBUTE_MAPPING_SIZE = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPING_SIZE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR' in found_values}}
 
     #: The start address of the mapping that the pointer belongs to
-    CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR{{endif}}
+    CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID' in found_values}}
 
     #: A process-wide unique id corresponding to the physical allocation
     #: the pointer belongs to
-    CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID = ccuda.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID{{endif}}
+    CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID = cydriver.CUpointer_attribute_enum.CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID{{endif}}
 {{endif}}
 {{if 'CUfunction_attribute_enum' in found_types}}
 
@@ -1515,27 +1516,27 @@ class CUfunction_attribute(IntEnum):
     #: The maximum number of threads per block, beyond which a launch of
     #: the function would fail. This number depends on both the function
     #: and the device on which the function is currently loaded.
-    CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK{{endif}}
+    CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES' in found_values}}
 
     #: The size in bytes of statically-allocated shared memory required by
     #: this function. This does not include dynamically-allocated shared
     #: memory requested by the user at runtime.
-    CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES{{endif}}
+    CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES' in found_values}}
 
     #: The size in bytes of user-allocated constant memory required by this
     #: function.
-    CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES{{endif}}
+    CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES' in found_values}}
 
     #: The size in bytes of local memory used by each thread of this
     #: function.
-    CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES{{endif}}
+    CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_NUM_REGS' in found_values}}
 
     #: The number of registers used by each thread of this function.
-    CU_FUNC_ATTRIBUTE_NUM_REGS = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NUM_REGS{{endif}}
+    CU_FUNC_ATTRIBUTE_NUM_REGS = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NUM_REGS{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_PTX_VERSION' in found_values}}
 
     #: The PTX virtual architecture version for which the function was
@@ -1543,7 +1544,7 @@ class CUfunction_attribute(IntEnum):
     #: version, so a PTX version 1.3 function would return the value 13.
     #: Note that this may return the undefined value of 0 for cubins
     #: compiled prior to CUDA 3.0.
-    CU_FUNC_ATTRIBUTE_PTX_VERSION = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PTX_VERSION{{endif}}
+    CU_FUNC_ATTRIBUTE_PTX_VERSION = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PTX_VERSION{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_BINARY_VERSION' in found_values}}
 
     #: The binary architecture version for which the function was compiled.
@@ -1551,19 +1552,19 @@ class CUfunction_attribute(IntEnum):
     #: version, so a binary version 1.3 function would return the value 13.
     #: Note that this will return a value of 10 for legacy cubins that do
     #: not have a properly-encoded binary architecture version.
-    CU_FUNC_ATTRIBUTE_BINARY_VERSION = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_BINARY_VERSION{{endif}}
+    CU_FUNC_ATTRIBUTE_BINARY_VERSION = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_BINARY_VERSION{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_CACHE_MODE_CA' in found_values}}
 
     #: The attribute to indicate whether the function has been compiled
     #: with user specified option "-Xptxas --dlcm=ca" set .
-    CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CACHE_MODE_CA{{endif}}
+    CU_FUNC_ATTRIBUTE_CACHE_MODE_CA = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CACHE_MODE_CA{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES' in found_values}}
 
     #: The maximum size in bytes of dynamically-allocated shared memory
     #: that can be used by this function. If the user-specified dynamic
     #: shared memory size is larger than this value, the launch will fail.
     #: See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES{{endif}}
+    CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT' in found_values}}
 
     #: On devices where the L1 cache and shared memory use the same
@@ -1572,12 +1573,12 @@ class CUfunction_attribute(IntEnum):
     #: :py:obj:`~.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR`.
     #: This is only a hint, and the driver can choose a different ratio if
     #: required to execute the function. See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT{{endif}}
+    CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET' in found_values}}
 
     #: If this attribute is set, the kernel must launch with a valid
     #: cluster size specified. See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET{{endif}}
+    CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH' in found_values}}
 
     #: The required cluster width in blocks. The values must either all be
@@ -1587,7 +1588,7 @@ class CUfunction_attribute(IntEnum):
     #: If the value is set during compile time, it cannot be set at
     #: runtime. Setting it at runtime will return CUDA_ERROR_NOT_PERMITTED.
     #: See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH{{endif}}
+    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT' in found_values}}
 
     #: The required cluster height in blocks. The values must either all be
@@ -1597,7 +1598,7 @@ class CUfunction_attribute(IntEnum):
     #: If the value is set during compile time, it cannot be set at
     #: runtime. Setting it at runtime should return
     #: CUDA_ERROR_NOT_PERMITTED. See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT{{endif}}
+    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH' in found_values}}
 
     #: The required cluster depth in blocks. The values must either all be
@@ -1607,7 +1608,7 @@ class CUfunction_attribute(IntEnum):
     #: If the value is set during compile time, it cannot be set at
     #: runtime. Setting it at runtime should return
     #: CUDA_ERROR_NOT_PERMITTED. See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH{{endif}}
+    CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED' in found_values}}
 
     #: Whether the function can be launched with non-portable cluster size.
@@ -1628,15 +1629,15 @@ class CUfunction_attribute(IntEnum):
     #:
     #: The specific hardware unit may support higher cluster sizes that’s
     #: not guaranteed to be portable. See :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED{{endif}}
+    CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
 
     #: The block scheduling policy of a function. The value type is
     #: CUclusterSchedulingPolicy / cudaClusterSchedulingPolicy. See
     #: :py:obj:`~.cuFuncSetAttribute`
-    CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
+    CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
     {{if 'CU_FUNC_ATTRIBUTE_MAX' in found_values}}
-    CU_FUNC_ATTRIBUTE_MAX = ccuda.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX{{endif}}
+    CU_FUNC_ATTRIBUTE_MAX = cydriver.CUfunction_attribute_enum.CU_FUNC_ATTRIBUTE_MAX{{endif}}
 {{endif}}
 {{if 'CUfunc_cache_enum' in found_types}}
 
@@ -1647,19 +1648,19 @@ class CUfunc_cache(IntEnum):
     {{if 'CU_FUNC_CACHE_PREFER_NONE' in found_values}}
 
     #: no preference for shared memory or L1 (default)
-    CU_FUNC_CACHE_PREFER_NONE = ccuda.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_NONE{{endif}}
+    CU_FUNC_CACHE_PREFER_NONE = cydriver.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_NONE{{endif}}
     {{if 'CU_FUNC_CACHE_PREFER_SHARED' in found_values}}
 
     #: prefer larger shared memory and smaller L1 cache
-    CU_FUNC_CACHE_PREFER_SHARED = ccuda.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_SHARED{{endif}}
+    CU_FUNC_CACHE_PREFER_SHARED = cydriver.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_SHARED{{endif}}
     {{if 'CU_FUNC_CACHE_PREFER_L1' in found_values}}
 
     #: prefer larger L1 cache and smaller shared memory
-    CU_FUNC_CACHE_PREFER_L1 = ccuda.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_L1{{endif}}
+    CU_FUNC_CACHE_PREFER_L1 = cydriver.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_L1{{endif}}
     {{if 'CU_FUNC_CACHE_PREFER_EQUAL' in found_values}}
 
     #: prefer equal sized L1 cache and shared memory
-    CU_FUNC_CACHE_PREFER_EQUAL = ccuda.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_EQUAL{{endif}}
+    CU_FUNC_CACHE_PREFER_EQUAL = cydriver.CUfunc_cache_enum.CU_FUNC_CACHE_PREFER_EQUAL{{endif}}
 {{endif}}
 {{if 'CUsharedconfig_enum' in found_types}}
 
@@ -1670,15 +1671,15 @@ class CUsharedconfig(IntEnum):
     {{if 'CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE' in found_values}}
 
     #: set default shared memory bank size
-    CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = ccuda.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE{{endif}}
+    CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE = cydriver.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE{{endif}}
     {{if 'CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE' in found_values}}
 
     #: set shared memory bank width to four bytes
-    CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = ccuda.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE{{endif}}
+    CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE = cydriver.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE{{endif}}
     {{if 'CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE' in found_values}}
 
     #: set shared memory bank width to eight bytes
-    CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = ccuda.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE{{endif}}
+    CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE = cydriver.CUsharedconfig_enum.CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE{{endif}}
 {{endif}}
 {{if 'CUshared_carveout_enum' in found_types}}
 
@@ -1690,15 +1691,15 @@ class CUshared_carveout(IntEnum):
     {{if 'CU_SHAREDMEM_CARVEOUT_DEFAULT' in found_values}}
 
     #: No preference for shared memory or L1 (default)
-    CU_SHAREDMEM_CARVEOUT_DEFAULT = ccuda.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_DEFAULT{{endif}}
-    {{if 'CU_SHAREDMEM_CARVEOUT_MAX_SHARED' in found_values}}
-
-    #: Prefer maximum available shared memory, minimum L1 cache
-    CU_SHAREDMEM_CARVEOUT_MAX_SHARED = ccuda.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_MAX_SHARED{{endif}}
+    CU_SHAREDMEM_CARVEOUT_DEFAULT = cydriver.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_DEFAULT{{endif}}
     {{if 'CU_SHAREDMEM_CARVEOUT_MAX_L1' in found_values}}
 
     #: Prefer maximum available L1 cache, minimum shared memory
-    CU_SHAREDMEM_CARVEOUT_MAX_L1 = ccuda.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_MAX_L1{{endif}}
+    CU_SHAREDMEM_CARVEOUT_MAX_L1 = cydriver.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_MAX_L1{{endif}}
+    {{if 'CU_SHAREDMEM_CARVEOUT_MAX_SHARED' in found_values}}
+
+    #: Prefer maximum available shared memory, minimum L1 cache
+    CU_SHAREDMEM_CARVEOUT_MAX_SHARED = cydriver.CUshared_carveout_enum.CU_SHAREDMEM_CARVEOUT_MAX_SHARED{{endif}}
 {{endif}}
 {{if 'CUmemorytype_enum' in found_types}}
 
@@ -1709,19 +1710,19 @@ class CUmemorytype(IntEnum):
     {{if 'CU_MEMORYTYPE_HOST' in found_values}}
 
     #: Host memory
-    CU_MEMORYTYPE_HOST = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_HOST{{endif}}
+    CU_MEMORYTYPE_HOST = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_HOST{{endif}}
     {{if 'CU_MEMORYTYPE_DEVICE' in found_values}}
 
     #: Device memory
-    CU_MEMORYTYPE_DEVICE = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE{{endif}}
+    CU_MEMORYTYPE_DEVICE = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_DEVICE{{endif}}
     {{if 'CU_MEMORYTYPE_ARRAY' in found_values}}
 
     #: Array memory
-    CU_MEMORYTYPE_ARRAY = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY{{endif}}
+    CU_MEMORYTYPE_ARRAY = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_ARRAY{{endif}}
     {{if 'CU_MEMORYTYPE_UNIFIED' in found_values}}
 
     #: Unified device or host memory
-    CU_MEMORYTYPE_UNIFIED = ccuda.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED{{endif}}
+    CU_MEMORYTYPE_UNIFIED = cydriver.CUmemorytype_enum.CU_MEMORYTYPE_UNIFIED{{endif}}
 {{endif}}
 {{if 'CUcomputemode_enum' in found_types}}
 
@@ -1732,17 +1733,17 @@ class CUcomputemode(IntEnum):
     {{if 'CU_COMPUTEMODE_DEFAULT' in found_values}}
 
     #: Default compute mode (Multiple contexts allowed per device)
-    CU_COMPUTEMODE_DEFAULT = ccuda.CUcomputemode_enum.CU_COMPUTEMODE_DEFAULT{{endif}}
+    CU_COMPUTEMODE_DEFAULT = cydriver.CUcomputemode_enum.CU_COMPUTEMODE_DEFAULT{{endif}}
     {{if 'CU_COMPUTEMODE_PROHIBITED' in found_values}}
 
     #: Compute-prohibited mode (No contexts can be created on this device
     #: at this time)
-    CU_COMPUTEMODE_PROHIBITED = ccuda.CUcomputemode_enum.CU_COMPUTEMODE_PROHIBITED{{endif}}
+    CU_COMPUTEMODE_PROHIBITED = cydriver.CUcomputemode_enum.CU_COMPUTEMODE_PROHIBITED{{endif}}
     {{if 'CU_COMPUTEMODE_EXCLUSIVE_PROCESS' in found_values}}
 
     #: Compute-exclusive-process mode (Only one context used by a single
     #: process can be present on this device at a time)
-    CU_COMPUTEMODE_EXCLUSIVE_PROCESS = ccuda.CUcomputemode_enum.CU_COMPUTEMODE_EXCLUSIVE_PROCESS{{endif}}
+    CU_COMPUTEMODE_EXCLUSIVE_PROCESS = cydriver.CUcomputemode_enum.CU_COMPUTEMODE_EXCLUSIVE_PROCESS{{endif}}
 {{endif}}
 {{if 'CUmem_advise_enum' in found_types}}
 
@@ -1753,29 +1754,29 @@ class CUmem_advise(IntEnum):
     {{if 'CU_MEM_ADVISE_SET_READ_MOSTLY' in found_values}}
 
     #: Data will mostly be read and only occassionally be written to
-    CU_MEM_ADVISE_SET_READ_MOSTLY = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_SET_READ_MOSTLY{{endif}}
+    CU_MEM_ADVISE_SET_READ_MOSTLY = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_SET_READ_MOSTLY{{endif}}
     {{if 'CU_MEM_ADVISE_UNSET_READ_MOSTLY' in found_values}}
 
     #: Undo the effect of :py:obj:`~.CU_MEM_ADVISE_SET_READ_MOSTLY`
-    CU_MEM_ADVISE_UNSET_READ_MOSTLY = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_READ_MOSTLY{{endif}}
+    CU_MEM_ADVISE_UNSET_READ_MOSTLY = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_READ_MOSTLY{{endif}}
     {{if 'CU_MEM_ADVISE_SET_PREFERRED_LOCATION' in found_values}}
 
     #: Set the preferred location for the data as the specified device
-    CU_MEM_ADVISE_SET_PREFERRED_LOCATION = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_SET_PREFERRED_LOCATION{{endif}}
+    CU_MEM_ADVISE_SET_PREFERRED_LOCATION = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_SET_PREFERRED_LOCATION{{endif}}
     {{if 'CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION' in found_values}}
 
     #: Clear the preferred location for the data
-    CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION{{endif}}
+    CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION{{endif}}
     {{if 'CU_MEM_ADVISE_SET_ACCESSED_BY' in found_values}}
 
     #: Data will be accessed by the specified device, so prevent page
     #: faults as much as possible
-    CU_MEM_ADVISE_SET_ACCESSED_BY = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_SET_ACCESSED_BY{{endif}}
+    CU_MEM_ADVISE_SET_ACCESSED_BY = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_SET_ACCESSED_BY{{endif}}
     {{if 'CU_MEM_ADVISE_UNSET_ACCESSED_BY' in found_values}}
 
     #: Let the Unified Memory subsystem decide on the page faulting policy
     #: for the specified device
-    CU_MEM_ADVISE_UNSET_ACCESSED_BY = ccuda.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_ACCESSED_BY{{endif}}
+    CU_MEM_ADVISE_UNSET_ACCESSED_BY = cydriver.CUmem_advise_enum.CU_MEM_ADVISE_UNSET_ACCESSED_BY{{endif}}
 {{endif}}
 {{if 'CUmem_range_attribute_enum' in found_types}}
 
@@ -1787,20 +1788,20 @@ class CUmem_range_attribute(IntEnum):
 
     #: Whether the range will mostly be read and only occassionally be
     #: written to
-    CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY{{endif}}
+    CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY = cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY{{endif}}
     {{if 'CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION' in found_values}}
 
     #: The preferred location of the range
-    CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION{{endif}}
+    CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION = cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION{{endif}}
     {{if 'CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY' in found_values}}
 
     #: Memory range has :py:obj:`~.CU_MEM_ADVISE_SET_ACCESSED_BY` set for
     #: specified device
-    CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY{{endif}}
+    CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY = cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY{{endif}}
     {{if 'CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION' in found_values}}
 
     #: The last location to which the range was prefetched
-    CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = ccuda.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION{{endif}}
+    CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION = cydriver.CUmem_range_attribute_enum.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION{{endif}}
 {{endif}}
 {{if 'CUjit_option_enum' in found_types}}
 
@@ -1813,7 +1814,7 @@ class CUjit_option(IntEnum):
     #: Max number of registers that a thread may use.
     #: Option type: unsigned int
     #: Applies to: compiler only
-    CU_JIT_MAX_REGISTERS = ccuda.CUjit_option_enum.CU_JIT_MAX_REGISTERS{{endif}}
+    CU_JIT_MAX_REGISTERS = cydriver.CUjit_option_enum.CU_JIT_MAX_REGISTERS{{endif}}
     {{if 'CU_JIT_THREADS_PER_BLOCK' in found_values}}
 
     #: IN: Specifies minimum number of threads per block to target
@@ -1827,14 +1828,14 @@ class CUjit_option(IntEnum):
     #: Cannot be combined with :py:obj:`~.CU_JIT_TARGET`.
     #: Option type: unsigned int
     #: Applies to: compiler only
-    CU_JIT_THREADS_PER_BLOCK = ccuda.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK{{endif}}
+    CU_JIT_THREADS_PER_BLOCK = cydriver.CUjit_option_enum.CU_JIT_THREADS_PER_BLOCK{{endif}}
     {{if 'CU_JIT_WALL_TIME' in found_values}}
 
     #: Overwrites the option value with the total wall clock time, in
     #: milliseconds, spent in the compiler and linker
     #: Option type: float
     #: Applies to: compiler and linker
-    CU_JIT_WALL_TIME = ccuda.CUjit_option_enum.CU_JIT_WALL_TIME{{endif}}
+    CU_JIT_WALL_TIME = cydriver.CUjit_option_enum.CU_JIT_WALL_TIME{{endif}}
     {{if 'CU_JIT_INFO_LOG_BUFFER' in found_values}}
 
     #: Pointer to a buffer in which to print any log messages that are
@@ -1842,7 +1843,7 @@ class CUjit_option(IntEnum):
     #: :py:obj:`~.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES`)
     #: Option type: char *
     #: Applies to: compiler and linker
-    CU_JIT_INFO_LOG_BUFFER = ccuda.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER{{endif}}
+    CU_JIT_INFO_LOG_BUFFER = cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER{{endif}}
     {{if 'CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES' in found_values}}
 
     #: IN: Log buffer size in bytes. Log messages will be capped at this
@@ -1850,7 +1851,7 @@ class CUjit_option(IntEnum):
     #: OUT: Amount of log buffer filled with messages
     #: Option type: unsigned int
     #: Applies to: compiler and linker
-    CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = ccuda.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES{{endif}}
+    CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES = cydriver.CUjit_option_enum.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES{{endif}}
     {{if 'CU_JIT_ERROR_LOG_BUFFER' in found_values}}
 
     #: Pointer to a buffer in which to print any log messages that reflect
@@ -1858,7 +1859,7 @@ class CUjit_option(IntEnum):
     #: :py:obj:`~.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES`)
     #: Option type: char *
     #: Applies to: compiler and linker
-    CU_JIT_ERROR_LOG_BUFFER = ccuda.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER{{endif}}
+    CU_JIT_ERROR_LOG_BUFFER = cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER{{endif}}
     {{if 'CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES' in found_values}}
 
     #: IN: Log buffer size in bytes. Log messages will be capped at this
@@ -1866,21 +1867,21 @@ class CUjit_option(IntEnum):
     #: OUT: Amount of log buffer filled with messages
     #: Option type: unsigned int
     #: Applies to: compiler and linker
-    CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = ccuda.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES{{endif}}
+    CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES = cydriver.CUjit_option_enum.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES{{endif}}
     {{if 'CU_JIT_OPTIMIZATION_LEVEL' in found_values}}
 
     #: Level of optimizations to apply to generated code (0 - 4), with 4
     #: being the default and highest level of optimizations.
     #: Option type: unsigned int
     #: Applies to: compiler only
-    CU_JIT_OPTIMIZATION_LEVEL = ccuda.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL{{endif}}
+    CU_JIT_OPTIMIZATION_LEVEL = cydriver.CUjit_option_enum.CU_JIT_OPTIMIZATION_LEVEL{{endif}}
     {{if 'CU_JIT_TARGET_FROM_CUCONTEXT' in found_values}}
 
     #: No option value required. Determines the target based on the current
     #: attached context (default)
     #: Option type: No option value needed
     #: Applies to: compiler and linker
-    CU_JIT_TARGET_FROM_CUCONTEXT = ccuda.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT{{endif}}
+    CU_JIT_TARGET_FROM_CUCONTEXT = cydriver.CUjit_option_enum.CU_JIT_TARGET_FROM_CUCONTEXT{{endif}}
     {{if 'CU_JIT_TARGET' in found_values}}
 
     #: Target is chosen based on supplied :py:obj:`~.CUjit_target`. Cannot
@@ -1888,7 +1889,7 @@ class CUjit_option(IntEnum):
     #: Option type: unsigned int for enumerated type
     #: :py:obj:`~.CUjit_target`
     #: Applies to: compiler and linker
-    CU_JIT_TARGET = ccuda.CUjit_option_enum.CU_JIT_TARGET{{endif}}
+    CU_JIT_TARGET = cydriver.CUjit_option_enum.CU_JIT_TARGET{{endif}}
     {{if 'CU_JIT_FALLBACK_STRATEGY' in found_values}}
 
     #: Specifies choice of fallback strategy if matching cubin is not
@@ -1898,26 +1899,26 @@ class CUjit_option(IntEnum):
     #: Option type: unsigned int for enumerated type
     #: :py:obj:`~.CUjit_fallback`
     #: Applies to: compiler only
-    CU_JIT_FALLBACK_STRATEGY = ccuda.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY{{endif}}
+    CU_JIT_FALLBACK_STRATEGY = cydriver.CUjit_option_enum.CU_JIT_FALLBACK_STRATEGY{{endif}}
     {{if 'CU_JIT_GENERATE_DEBUG_INFO' in found_values}}
 
     #: Specifies whether to create debug information in output (-g) (0:
     #: false, default)
     #: Option type: int
     #: Applies to: compiler and linker
-    CU_JIT_GENERATE_DEBUG_INFO = ccuda.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO{{endif}}
+    CU_JIT_GENERATE_DEBUG_INFO = cydriver.CUjit_option_enum.CU_JIT_GENERATE_DEBUG_INFO{{endif}}
     {{if 'CU_JIT_LOG_VERBOSE' in found_values}}
 
     #: Generate verbose log messages (0: false, default)
     #: Option type: int
     #: Applies to: compiler and linker
-    CU_JIT_LOG_VERBOSE = ccuda.CUjit_option_enum.CU_JIT_LOG_VERBOSE{{endif}}
+    CU_JIT_LOG_VERBOSE = cydriver.CUjit_option_enum.CU_JIT_LOG_VERBOSE{{endif}}
     {{if 'CU_JIT_GENERATE_LINE_INFO' in found_values}}
 
     #: Generate line number information (-lineinfo) (0: false, default)
     #: Option type: int
     #: Applies to: compiler only
-    CU_JIT_GENERATE_LINE_INFO = ccuda.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO{{endif}}
+    CU_JIT_GENERATE_LINE_INFO = cydriver.CUjit_option_enum.CU_JIT_GENERATE_LINE_INFO{{endif}}
     {{if 'CU_JIT_CACHE_MODE' in found_values}}
 
     #: Specifies whether to enable caching explicitly (-dlcm)
@@ -1925,15 +1926,15 @@ class CUjit_option(IntEnum):
     #: Option type: unsigned int for enumerated type
     #: :py:obj:`~.CUjit_cacheMode_enum`
     #: Applies to: compiler only
-    CU_JIT_CACHE_MODE = ccuda.CUjit_option_enum.CU_JIT_CACHE_MODE{{endif}}
+    CU_JIT_CACHE_MODE = cydriver.CUjit_option_enum.CU_JIT_CACHE_MODE{{endif}}
     {{if 'CU_JIT_NEW_SM3X_OPT' in found_values}}
 
     #: [Deprecated]
-    CU_JIT_NEW_SM3X_OPT = ccuda.CUjit_option_enum.CU_JIT_NEW_SM3X_OPT{{endif}}
+    CU_JIT_NEW_SM3X_OPT = cydriver.CUjit_option_enum.CU_JIT_NEW_SM3X_OPT{{endif}}
     {{if 'CU_JIT_FAST_COMPILE' in found_values}}
 
     #: This jit option is used for internal purpose only.
-    CU_JIT_FAST_COMPILE = ccuda.CUjit_option_enum.CU_JIT_FAST_COMPILE{{endif}}
+    CU_JIT_FAST_COMPILE = cydriver.CUjit_option_enum.CU_JIT_FAST_COMPILE{{endif}}
     {{if 'CU_JIT_GLOBAL_SYMBOL_NAMES' in found_values}}
 
     #: Array of device symbol names that will be relocated to the
@@ -1948,7 +1949,7 @@ class CUjit_option(IntEnum):
     #: addresses.
     #: Option type: const char **
     #: Applies to: dynamic linker only
-    CU_JIT_GLOBAL_SYMBOL_NAMES = ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES{{endif}}
+    CU_JIT_GLOBAL_SYMBOL_NAMES = cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_NAMES{{endif}}
     {{if 'CU_JIT_GLOBAL_SYMBOL_ADDRESSES' in found_values}}
 
     #: Array of host addresses that will be used to relocate corresponding
@@ -1956,14 +1957,14 @@ class CUjit_option(IntEnum):
     #: Must contain :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_COUNT` entries.
     #: Option type: void **
     #: Applies to: dynamic linker only
-    CU_JIT_GLOBAL_SYMBOL_ADDRESSES = ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES{{endif}}
+    CU_JIT_GLOBAL_SYMBOL_ADDRESSES = cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_ADDRESSES{{endif}}
     {{if 'CU_JIT_GLOBAL_SYMBOL_COUNT' in found_values}}
 
     #: Number of entries in :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_NAMES` and
     #: :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_ADDRESSES` arrays.
     #: Option type: unsigned int
     #: Applies to: dynamic linker only
-    CU_JIT_GLOBAL_SYMBOL_COUNT = ccuda.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT{{endif}}
+    CU_JIT_GLOBAL_SYMBOL_COUNT = cydriver.CUjit_option_enum.CU_JIT_GLOBAL_SYMBOL_COUNT{{endif}}
     {{if 'CU_JIT_LTO' in found_values}}
 
     #: Enable link-time optimization (-dlto) for device code (Disabled by
@@ -1971,14 +1972,14 @@ class CUjit_option(IntEnum):
     #: This option is not supported on 32-bit platforms.
     #: Option type: int
     #: Applies to: compiler and linker
-    CU_JIT_LTO = ccuda.CUjit_option_enum.CU_JIT_LTO{{endif}}
+    CU_JIT_LTO = cydriver.CUjit_option_enum.CU_JIT_LTO{{endif}}
     {{if 'CU_JIT_FTZ' in found_values}}
 
     #: Control single-precision denormals (-ftz) support (0: false,
     #: default). 1 : flushes denormal values to zero 0 : preserves denormal
     #: values Option type: int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_FTZ = ccuda.CUjit_option_enum.CU_JIT_FTZ{{endif}}
+    CU_JIT_FTZ = cydriver.CUjit_option_enum.CU_JIT_FTZ{{endif}}
     {{if 'CU_JIT_PREC_DIV' in found_values}}
 
     #: Control single-precision floating-point division and reciprocals
@@ -1986,21 +1987,21 @@ class CUjit_option(IntEnum):
     #: to-nearest mode 0 : Enables the fast approximation mode Option type:
     #: int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_PREC_DIV = ccuda.CUjit_option_enum.CU_JIT_PREC_DIV{{endif}}
+    CU_JIT_PREC_DIV = cydriver.CUjit_option_enum.CU_JIT_PREC_DIV{{endif}}
     {{if 'CU_JIT_PREC_SQRT' in found_values}}
 
     #: Control single-precision floating-point square root (-prec-sqrt)
     #: support (1: true, default). 1 : Enables the IEEE round-to-nearest
     #: mode 0 : Enables the fast approximation mode Option type: int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_PREC_SQRT = ccuda.CUjit_option_enum.CU_JIT_PREC_SQRT{{endif}}
+    CU_JIT_PREC_SQRT = cydriver.CUjit_option_enum.CU_JIT_PREC_SQRT{{endif}}
     {{if 'CU_JIT_FMA' in found_values}}
 
     #: Enable/Disable the contraction of floating-point multiplies and
     #: adds/subtracts into floating-point multiply-add (-fma) operations
     #: (1: Enable, default; 0: Disable). Option type: int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_FMA = ccuda.CUjit_option_enum.CU_JIT_FMA{{endif}}
+    CU_JIT_FMA = cydriver.CUjit_option_enum.CU_JIT_FMA{{endif}}
     {{if 'CU_JIT_REFERENCED_KERNEL_NAMES' in found_values}}
 
     #: Array of kernel names that should be preserved at link time while
@@ -2017,14 +2018,14 @@ class CUjit_option(IntEnum):
     #: "barfoobaz".
     #: Option type: const char **
     #: Applies to: dynamic linker only
-    CU_JIT_REFERENCED_KERNEL_NAMES = ccuda.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_NAMES{{endif}}
+    CU_JIT_REFERENCED_KERNEL_NAMES = cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_NAMES{{endif}}
     {{if 'CU_JIT_REFERENCED_KERNEL_COUNT' in found_values}}
 
     #: Number of entries in :py:obj:`~.CU_JIT_REFERENCED_KERNEL_NAMES`
     #: array.
     #: Option type: unsigned int
     #: Applies to: dynamic linker only
-    CU_JIT_REFERENCED_KERNEL_COUNT = ccuda.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_COUNT{{endif}}
+    CU_JIT_REFERENCED_KERNEL_COUNT = cydriver.CUjit_option_enum.CU_JIT_REFERENCED_KERNEL_COUNT{{endif}}
     {{if 'CU_JIT_REFERENCED_VARIABLE_NAMES' in found_values}}
 
     #: Array of variable names (device and/or constant) that should be
@@ -2041,14 +2042,14 @@ class CUjit_option(IntEnum):
     #: "barfoobaz".
     #: Option type: const char **
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_REFERENCED_VARIABLE_NAMES = ccuda.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_NAMES{{endif}}
+    CU_JIT_REFERENCED_VARIABLE_NAMES = cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_NAMES{{endif}}
     {{if 'CU_JIT_REFERENCED_VARIABLE_COUNT' in found_values}}
 
     #: Number of entries in :py:obj:`~.CU_JIT_REFERENCED_VARIABLE_NAMES`
     #: array.
     #: Option type: unsigned int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_REFERENCED_VARIABLE_COUNT = ccuda.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_COUNT{{endif}}
+    CU_JIT_REFERENCED_VARIABLE_COUNT = cydriver.CUjit_option_enum.CU_JIT_REFERENCED_VARIABLE_COUNT{{endif}}
     {{if 'CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES' in found_values}}
 
     #: This option serves as a hint to enable the JIT compiler/linker to
@@ -2060,9 +2061,9 @@ class CUjit_option(IntEnum):
     #: specified using :py:obj:`~.CU_JIT_REFERENCED_VARIABLE_NAMES`.
     #: Option type: int
     #: Applies to: link-time optimization specified with CU_JIT_LTO
-    CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES = ccuda.CUjit_option_enum.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES{{endif}}
+    CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES = cydriver.CUjit_option_enum.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES{{endif}}
     {{if 'CU_JIT_NUM_OPTIONS' in found_values}}
-    CU_JIT_NUM_OPTIONS = ccuda.CUjit_option_enum.CU_JIT_NUM_OPTIONS{{endif}}
+    CU_JIT_NUM_OPTIONS = cydriver.CUjit_option_enum.CU_JIT_NUM_OPTIONS{{endif}}
 {{endif}}
 {{if 'CUjit_target_enum' in found_types}}
 
@@ -2073,83 +2074,83 @@ class CUjit_target(IntEnum):
     {{if 'CU_TARGET_COMPUTE_20' in found_values}}
 
     #: Compute device class 2.0
-    CU_TARGET_COMPUTE_20 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_20{{endif}}
+    CU_TARGET_COMPUTE_20 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_20{{endif}}
     {{if 'CU_TARGET_COMPUTE_21' in found_values}}
 
     #: Compute device class 2.1
-    CU_TARGET_COMPUTE_21 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_21{{endif}}
+    CU_TARGET_COMPUTE_21 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_21{{endif}}
     {{if 'CU_TARGET_COMPUTE_30' in found_values}}
 
     #: Compute device class 3.0
-    CU_TARGET_COMPUTE_30 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_30{{endif}}
+    CU_TARGET_COMPUTE_30 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_30{{endif}}
     {{if 'CU_TARGET_COMPUTE_32' in found_values}}
 
     #: Compute device class 3.2
-    CU_TARGET_COMPUTE_32 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_32{{endif}}
+    CU_TARGET_COMPUTE_32 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_32{{endif}}
     {{if 'CU_TARGET_COMPUTE_35' in found_values}}
 
     #: Compute device class 3.5
-    CU_TARGET_COMPUTE_35 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_35{{endif}}
+    CU_TARGET_COMPUTE_35 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_35{{endif}}
     {{if 'CU_TARGET_COMPUTE_37' in found_values}}
 
     #: Compute device class 3.7
-    CU_TARGET_COMPUTE_37 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_37{{endif}}
+    CU_TARGET_COMPUTE_37 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_37{{endif}}
     {{if 'CU_TARGET_COMPUTE_50' in found_values}}
 
     #: Compute device class 5.0
-    CU_TARGET_COMPUTE_50 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_50{{endif}}
+    CU_TARGET_COMPUTE_50 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_50{{endif}}
     {{if 'CU_TARGET_COMPUTE_52' in found_values}}
 
     #: Compute device class 5.2
-    CU_TARGET_COMPUTE_52 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_52{{endif}}
+    CU_TARGET_COMPUTE_52 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_52{{endif}}
     {{if 'CU_TARGET_COMPUTE_53' in found_values}}
 
     #: Compute device class 5.3
-    CU_TARGET_COMPUTE_53 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_53{{endif}}
+    CU_TARGET_COMPUTE_53 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_53{{endif}}
     {{if 'CU_TARGET_COMPUTE_60' in found_values}}
 
     #: Compute device class 6.0.
-    CU_TARGET_COMPUTE_60 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_60{{endif}}
+    CU_TARGET_COMPUTE_60 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_60{{endif}}
     {{if 'CU_TARGET_COMPUTE_61' in found_values}}
 
     #: Compute device class 6.1.
-    CU_TARGET_COMPUTE_61 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_61{{endif}}
+    CU_TARGET_COMPUTE_61 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_61{{endif}}
     {{if 'CU_TARGET_COMPUTE_62' in found_values}}
 
     #: Compute device class 6.2.
-    CU_TARGET_COMPUTE_62 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_62{{endif}}
+    CU_TARGET_COMPUTE_62 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_62{{endif}}
     {{if 'CU_TARGET_COMPUTE_70' in found_values}}
 
     #: Compute device class 7.0.
-    CU_TARGET_COMPUTE_70 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_70{{endif}}
+    CU_TARGET_COMPUTE_70 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_70{{endif}}
     {{if 'CU_TARGET_COMPUTE_72' in found_values}}
 
     #: Compute device class 7.2.
-    CU_TARGET_COMPUTE_72 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_72{{endif}}
+    CU_TARGET_COMPUTE_72 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_72{{endif}}
     {{if 'CU_TARGET_COMPUTE_75' in found_values}}
 
     #: Compute device class 7.5.
-    CU_TARGET_COMPUTE_75 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_75{{endif}}
+    CU_TARGET_COMPUTE_75 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_75{{endif}}
     {{if 'CU_TARGET_COMPUTE_80' in found_values}}
 
     #: Compute device class 8.0.
-    CU_TARGET_COMPUTE_80 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_80{{endif}}
+    CU_TARGET_COMPUTE_80 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_80{{endif}}
     {{if 'CU_TARGET_COMPUTE_86' in found_values}}
 
     #: Compute device class 8.6.
-    CU_TARGET_COMPUTE_86 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_86{{endif}}
+    CU_TARGET_COMPUTE_86 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_86{{endif}}
     {{if 'CU_TARGET_COMPUTE_87' in found_values}}
 
     #: Compute device class 8.7.
-    CU_TARGET_COMPUTE_87 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_87{{endif}}
+    CU_TARGET_COMPUTE_87 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_87{{endif}}
     {{if 'CU_TARGET_COMPUTE_89' in found_values}}
 
     #: Compute device class 8.9.
-    CU_TARGET_COMPUTE_89 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_89{{endif}}
+    CU_TARGET_COMPUTE_89 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_89{{endif}}
     {{if 'CU_TARGET_COMPUTE_90' in found_values}}
 
     #: Compute device class 9.0.
-    CU_TARGET_COMPUTE_90 = ccuda.CUjit_target_enum.CU_TARGET_COMPUTE_90{{endif}}
+    CU_TARGET_COMPUTE_90 = cydriver.CUjit_target_enum.CU_TARGET_COMPUTE_90{{endif}}
 {{endif}}
 {{if 'CUjit_fallback_enum' in found_types}}
 
@@ -2160,12 +2161,12 @@ class CUjit_fallback(IntEnum):
     {{if 'CU_PREFER_PTX' in found_values}}
 
     #: Prefer to compile ptx if exact binary match not found
-    CU_PREFER_PTX = ccuda.CUjit_fallback_enum.CU_PREFER_PTX{{endif}}
+    CU_PREFER_PTX = cydriver.CUjit_fallback_enum.CU_PREFER_PTX{{endif}}
     {{if 'CU_PREFER_BINARY' in found_values}}
 
     #: Prefer to fall back to compatible binary code if exact match not
     #: found
-    CU_PREFER_BINARY = ccuda.CUjit_fallback_enum.CU_PREFER_BINARY{{endif}}
+    CU_PREFER_BINARY = cydriver.CUjit_fallback_enum.CU_PREFER_BINARY{{endif}}
 {{endif}}
 {{if 'CUjit_cacheMode_enum' in found_types}}
 
@@ -2176,15 +2177,15 @@ class CUjit_cacheMode(IntEnum):
     {{if 'CU_JIT_CACHE_OPTION_NONE' in found_values}}
 
     #: Compile with no -dlcm flag specified
-    CU_JIT_CACHE_OPTION_NONE = ccuda.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_NONE{{endif}}
+    CU_JIT_CACHE_OPTION_NONE = cydriver.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_NONE{{endif}}
     {{if 'CU_JIT_CACHE_OPTION_CG' in found_values}}
 
     #: Compile with L1 cache disabled
-    CU_JIT_CACHE_OPTION_CG = ccuda.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_CG{{endif}}
+    CU_JIT_CACHE_OPTION_CG = cydriver.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_CG{{endif}}
     {{if 'CU_JIT_CACHE_OPTION_CA' in found_values}}
 
     #: Compile with L1 cache enabled
-    CU_JIT_CACHE_OPTION_CA = ccuda.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_CA{{endif}}
+    CU_JIT_CACHE_OPTION_CA = cydriver.CUjit_cacheMode_enum.CU_JIT_CACHE_OPTION_CA{{endif}}
 {{endif}}
 {{if 'CUjitInputType_enum' in found_types}}
 
@@ -2196,37 +2197,37 @@ class CUjitInputType(IntEnum):
 
     #: Compiled device-class-specific device code
     #: Applicable options: none
-    CU_JIT_INPUT_CUBIN = ccuda.CUjitInputType_enum.CU_JIT_INPUT_CUBIN{{endif}}
+    CU_JIT_INPUT_CUBIN = cydriver.CUjitInputType_enum.CU_JIT_INPUT_CUBIN{{endif}}
     {{if 'CU_JIT_INPUT_PTX' in found_values}}
 
     #: PTX source code
     #: Applicable options: PTX compiler options
-    CU_JIT_INPUT_PTX = ccuda.CUjitInputType_enum.CU_JIT_INPUT_PTX{{endif}}
+    CU_JIT_INPUT_PTX = cydriver.CUjitInputType_enum.CU_JIT_INPUT_PTX{{endif}}
     {{if 'CU_JIT_INPUT_FATBINARY' in found_values}}
 
     #: Bundle of multiple cubins and/or PTX of some device code
     #: Applicable options: PTX compiler options,
     #: :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
-    CU_JIT_INPUT_FATBINARY = ccuda.CUjitInputType_enum.CU_JIT_INPUT_FATBINARY{{endif}}
+    CU_JIT_INPUT_FATBINARY = cydriver.CUjitInputType_enum.CU_JIT_INPUT_FATBINARY{{endif}}
     {{if 'CU_JIT_INPUT_OBJECT' in found_values}}
 
     #: Host object with embedded device code
     #: Applicable options: PTX compiler options,
     #: :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
-    CU_JIT_INPUT_OBJECT = ccuda.CUjitInputType_enum.CU_JIT_INPUT_OBJECT{{endif}}
+    CU_JIT_INPUT_OBJECT = cydriver.CUjitInputType_enum.CU_JIT_INPUT_OBJECT{{endif}}
     {{if 'CU_JIT_INPUT_LIBRARY' in found_values}}
 
     #: Archive of host objects with embedded device code
     #: Applicable options: PTX compiler options,
     #: :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
-    CU_JIT_INPUT_LIBRARY = ccuda.CUjitInputType_enum.CU_JIT_INPUT_LIBRARY{{endif}}
+    CU_JIT_INPUT_LIBRARY = cydriver.CUjitInputType_enum.CU_JIT_INPUT_LIBRARY{{endif}}
     {{if 'CU_JIT_INPUT_NVVM' in found_values}}
 
     #: High-level intermediate code for link-time optimization
     #: Applicable options: NVVM compiler options, PTX compiler options
-    CU_JIT_INPUT_NVVM = ccuda.CUjitInputType_enum.CU_JIT_INPUT_NVVM{{endif}}
+    CU_JIT_INPUT_NVVM = cydriver.CUjitInputType_enum.CU_JIT_INPUT_NVVM{{endif}}
     {{if 'CU_JIT_NUM_INPUT_TYPES' in found_values}}
-    CU_JIT_NUM_INPUT_TYPES = ccuda.CUjitInputType_enum.CU_JIT_NUM_INPUT_TYPES{{endif}}
+    CU_JIT_NUM_INPUT_TYPES = cydriver.CUjitInputType_enum.CU_JIT_NUM_INPUT_TYPES{{endif}}
 {{endif}}
 {{if 'CUgraphicsRegisterFlags_enum' in found_types}}
 
@@ -2235,15 +2236,15 @@ class CUgraphicsRegisterFlags(IntEnum):
     Flags to register a graphics resource
     """
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_NONE' in found_values}}
-    CU_GRAPHICS_REGISTER_FLAGS_NONE = ccuda.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_NONE{{endif}}
+    CU_GRAPHICS_REGISTER_FLAGS_NONE = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_NONE{{endif}}
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY' in found_values}}
-    CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = ccuda.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY{{endif}}
+    CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY{{endif}}
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD' in found_values}}
-    CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = ccuda.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD{{endif}}
+    CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD{{endif}}
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST' in found_values}}
-    CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = ccuda.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST{{endif}}
+    CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST{{endif}}
     {{if 'CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER' in found_values}}
-    CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = ccuda.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER{{endif}}
+    CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = cydriver.CUgraphicsRegisterFlags_enum.CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER{{endif}}
 {{endif}}
 {{if 'CUgraphicsMapResourceFlags_enum' in found_types}}
 
@@ -2252,11 +2253,11 @@ class CUgraphicsMapResourceFlags(IntEnum):
     Flags for mapping and unmapping interop resources
     """
     {{if 'CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE' in found_values}}
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = ccuda.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE{{endif}}
+    CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = cydriver.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE{{endif}}
     {{if 'CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY' in found_values}}
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = ccuda.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
+    CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = cydriver.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
     {{if 'CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD' in found_values}}
-    CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = ccuda.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
+    CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = cydriver.CUgraphicsMapResourceFlags_enum.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
 {{endif}}
 {{if 'CUarray_cubemap_face_enum' in found_types}}
 
@@ -2267,27 +2268,27 @@ class CUarray_cubemap_face(IntEnum):
     {{if 'CU_CUBEMAP_FACE_POSITIVE_X' in found_values}}
 
     #: Positive X face of cubemap
-    CU_CUBEMAP_FACE_POSITIVE_X = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_X{{endif}}
+    CU_CUBEMAP_FACE_POSITIVE_X = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_X{{endif}}
     {{if 'CU_CUBEMAP_FACE_NEGATIVE_X' in found_values}}
 
     #: Negative X face of cubemap
-    CU_CUBEMAP_FACE_NEGATIVE_X = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_X{{endif}}
+    CU_CUBEMAP_FACE_NEGATIVE_X = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_X{{endif}}
     {{if 'CU_CUBEMAP_FACE_POSITIVE_Y' in found_values}}
 
     #: Positive Y face of cubemap
-    CU_CUBEMAP_FACE_POSITIVE_Y = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_Y{{endif}}
+    CU_CUBEMAP_FACE_POSITIVE_Y = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_Y{{endif}}
     {{if 'CU_CUBEMAP_FACE_NEGATIVE_Y' in found_values}}
 
     #: Negative Y face of cubemap
-    CU_CUBEMAP_FACE_NEGATIVE_Y = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_Y{{endif}}
+    CU_CUBEMAP_FACE_NEGATIVE_Y = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_Y{{endif}}
     {{if 'CU_CUBEMAP_FACE_POSITIVE_Z' in found_values}}
 
     #: Positive Z face of cubemap
-    CU_CUBEMAP_FACE_POSITIVE_Z = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_Z{{endif}}
+    CU_CUBEMAP_FACE_POSITIVE_Z = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_POSITIVE_Z{{endif}}
     {{if 'CU_CUBEMAP_FACE_NEGATIVE_Z' in found_values}}
 
     #: Negative Z face of cubemap
-    CU_CUBEMAP_FACE_NEGATIVE_Z = ccuda.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_Z{{endif}}
+    CU_CUBEMAP_FACE_NEGATIVE_Z = cydriver.CUarray_cubemap_face_enum.CU_CUBEMAP_FACE_NEGATIVE_Z{{endif}}
 {{endif}}
 {{if 'CUlimit_enum' in found_types}}
 
@@ -2298,34 +2299,34 @@ class CUlimit(IntEnum):
     {{if 'CU_LIMIT_STACK_SIZE' in found_values}}
 
     #: GPU thread stack size
-    CU_LIMIT_STACK_SIZE = ccuda.CUlimit_enum.CU_LIMIT_STACK_SIZE{{endif}}
+    CU_LIMIT_STACK_SIZE = cydriver.CUlimit_enum.CU_LIMIT_STACK_SIZE{{endif}}
     {{if 'CU_LIMIT_PRINTF_FIFO_SIZE' in found_values}}
 
     #: GPU printf FIFO size
-    CU_LIMIT_PRINTF_FIFO_SIZE = ccuda.CUlimit_enum.CU_LIMIT_PRINTF_FIFO_SIZE{{endif}}
+    CU_LIMIT_PRINTF_FIFO_SIZE = cydriver.CUlimit_enum.CU_LIMIT_PRINTF_FIFO_SIZE{{endif}}
     {{if 'CU_LIMIT_MALLOC_HEAP_SIZE' in found_values}}
 
     #: GPU malloc heap size
-    CU_LIMIT_MALLOC_HEAP_SIZE = ccuda.CUlimit_enum.CU_LIMIT_MALLOC_HEAP_SIZE{{endif}}
+    CU_LIMIT_MALLOC_HEAP_SIZE = cydriver.CUlimit_enum.CU_LIMIT_MALLOC_HEAP_SIZE{{endif}}
     {{if 'CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH' in found_values}}
 
     #: GPU device runtime launch synchronize depth
-    CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = ccuda.CUlimit_enum.CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH{{endif}}
+    CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH = cydriver.CUlimit_enum.CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH{{endif}}
     {{if 'CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT' in found_values}}
 
     #: GPU device runtime pending launch count
-    CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = ccuda.CUlimit_enum.CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT{{endif}}
+    CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT = cydriver.CUlimit_enum.CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT{{endif}}
     {{if 'CU_LIMIT_MAX_L2_FETCH_GRANULARITY' in found_values}}
 
     #: A value between 0 and 128 that indicates the maximum fetch
     #: granularity of L2 (in Bytes). This is a hint
-    CU_LIMIT_MAX_L2_FETCH_GRANULARITY = ccuda.CUlimit_enum.CU_LIMIT_MAX_L2_FETCH_GRANULARITY{{endif}}
+    CU_LIMIT_MAX_L2_FETCH_GRANULARITY = cydriver.CUlimit_enum.CU_LIMIT_MAX_L2_FETCH_GRANULARITY{{endif}}
     {{if 'CU_LIMIT_PERSISTING_L2_CACHE_SIZE' in found_values}}
 
     #: A size in bytes for L2 persisting lines cache size
-    CU_LIMIT_PERSISTING_L2_CACHE_SIZE = ccuda.CUlimit_enum.CU_LIMIT_PERSISTING_L2_CACHE_SIZE{{endif}}
+    CU_LIMIT_PERSISTING_L2_CACHE_SIZE = cydriver.CUlimit_enum.CU_LIMIT_PERSISTING_L2_CACHE_SIZE{{endif}}
     {{if 'CU_LIMIT_MAX' in found_values}}
-    CU_LIMIT_MAX = ccuda.CUlimit_enum.CU_LIMIT_MAX{{endif}}
+    CU_LIMIT_MAX = cydriver.CUlimit_enum.CU_LIMIT_MAX{{endif}}
 {{endif}}
 {{if 'CUresourcetype_enum' in found_types}}
 
@@ -2336,19 +2337,19 @@ class CUresourcetype(IntEnum):
     {{if 'CU_RESOURCE_TYPE_ARRAY' in found_values}}
 
     #: Array resoure
-    CU_RESOURCE_TYPE_ARRAY = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY{{endif}}
+    CU_RESOURCE_TYPE_ARRAY = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_ARRAY{{endif}}
     {{if 'CU_RESOURCE_TYPE_MIPMAPPED_ARRAY' in found_values}}
 
     #: Mipmapped array resource
-    CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY{{endif}}
+    CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY{{endif}}
     {{if 'CU_RESOURCE_TYPE_LINEAR' in found_values}}
 
     #: Linear resource
-    CU_RESOURCE_TYPE_LINEAR = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR{{endif}}
+    CU_RESOURCE_TYPE_LINEAR = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_LINEAR{{endif}}
     {{if 'CU_RESOURCE_TYPE_PITCH2D' in found_values}}
 
     #: Pitch 2D resource
-    CU_RESOURCE_TYPE_PITCH2D = ccuda.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D{{endif}}
+    CU_RESOURCE_TYPE_PITCH2D = cydriver.CUresourcetype_enum.CU_RESOURCE_TYPE_PITCH2D{{endif}}
 {{endif}}
 {{if 'CUaccessProperty_enum' in found_types}}
 
@@ -2360,15 +2361,15 @@ class CUaccessProperty(IntEnum):
     {{if 'CU_ACCESS_PROPERTY_NORMAL' in found_values}}
 
     #: Normal cache persistence.
-    CU_ACCESS_PROPERTY_NORMAL = ccuda.CUaccessProperty_enum.CU_ACCESS_PROPERTY_NORMAL{{endif}}
+    CU_ACCESS_PROPERTY_NORMAL = cydriver.CUaccessProperty_enum.CU_ACCESS_PROPERTY_NORMAL{{endif}}
     {{if 'CU_ACCESS_PROPERTY_STREAMING' in found_values}}
 
     #: Streaming access is less likely to persit from cache.
-    CU_ACCESS_PROPERTY_STREAMING = ccuda.CUaccessProperty_enum.CU_ACCESS_PROPERTY_STREAMING{{endif}}
+    CU_ACCESS_PROPERTY_STREAMING = cydriver.CUaccessProperty_enum.CU_ACCESS_PROPERTY_STREAMING{{endif}}
     {{if 'CU_ACCESS_PROPERTY_PERSISTING' in found_values}}
 
     #: Persisting access is more likely to persist in cache.
-    CU_ACCESS_PROPERTY_PERSISTING = ccuda.CUaccessProperty_enum.CU_ACCESS_PROPERTY_PERSISTING{{endif}}
+    CU_ACCESS_PROPERTY_PERSISTING = cydriver.CUaccessProperty_enum.CU_ACCESS_PROPERTY_PERSISTING{{endif}}
 {{endif}}
 {{if 'CUgraphNodeType_enum' in found_types}}
 
@@ -2379,55 +2380,55 @@ class CUgraphNodeType(IntEnum):
     {{if 'CU_GRAPH_NODE_TYPE_KERNEL' in found_values}}
 
     #: GPU kernel node
-    CU_GRAPH_NODE_TYPE_KERNEL = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_KERNEL{{endif}}
+    CU_GRAPH_NODE_TYPE_KERNEL = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_KERNEL{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_MEMCPY' in found_values}}
 
     #: Memcpy node
-    CU_GRAPH_NODE_TYPE_MEMCPY = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEMCPY{{endif}}
+    CU_GRAPH_NODE_TYPE_MEMCPY = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEMCPY{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_MEMSET' in found_values}}
 
     #: Memset node
-    CU_GRAPH_NODE_TYPE_MEMSET = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEMSET{{endif}}
+    CU_GRAPH_NODE_TYPE_MEMSET = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEMSET{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_HOST' in found_values}}
 
     #: Host (executable) node
-    CU_GRAPH_NODE_TYPE_HOST = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_HOST{{endif}}
+    CU_GRAPH_NODE_TYPE_HOST = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_HOST{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_GRAPH' in found_values}}
 
     #: Node which executes an embedded graph
-    CU_GRAPH_NODE_TYPE_GRAPH = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_GRAPH{{endif}}
+    CU_GRAPH_NODE_TYPE_GRAPH = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_GRAPH{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_EMPTY' in found_values}}
 
     #: Empty (no-op) node
-    CU_GRAPH_NODE_TYPE_EMPTY = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EMPTY{{endif}}
+    CU_GRAPH_NODE_TYPE_EMPTY = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EMPTY{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_WAIT_EVENT' in found_values}}
 
     #: External event wait node
-    CU_GRAPH_NODE_TYPE_WAIT_EVENT = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_WAIT_EVENT{{endif}}
+    CU_GRAPH_NODE_TYPE_WAIT_EVENT = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_WAIT_EVENT{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_EVENT_RECORD' in found_values}}
 
     #: External event record node
-    CU_GRAPH_NODE_TYPE_EVENT_RECORD = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EVENT_RECORD{{endif}}
+    CU_GRAPH_NODE_TYPE_EVENT_RECORD = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EVENT_RECORD{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL' in found_values}}
 
     #: External semaphore signal node
-    CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL{{endif}}
+    CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT' in found_values}}
 
     #: External semaphore wait node
-    CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT{{endif}}
+    CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_MEM_ALLOC' in found_values}}
 
     #: Memory Allocation Node
-    CU_GRAPH_NODE_TYPE_MEM_ALLOC = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEM_ALLOC{{endif}}
+    CU_GRAPH_NODE_TYPE_MEM_ALLOC = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEM_ALLOC{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_MEM_FREE' in found_values}}
 
     #: Memory Free Node
-    CU_GRAPH_NODE_TYPE_MEM_FREE = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEM_FREE{{endif}}
+    CU_GRAPH_NODE_TYPE_MEM_FREE = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_MEM_FREE{{endif}}
     {{if 'CU_GRAPH_NODE_TYPE_BATCH_MEM_OP' in found_values}}
 
     #: Batch MemOp Node
-    CU_GRAPH_NODE_TYPE_BATCH_MEM_OP = ccuda.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_BATCH_MEM_OP{{endif}}
+    CU_GRAPH_NODE_TYPE_BATCH_MEM_OP = cydriver.CUgraphNodeType_enum.CU_GRAPH_NODE_TYPE_BATCH_MEM_OP{{endif}}
 {{endif}}
 {{if 'CUsynchronizationPolicy_enum' in found_types}}
 
@@ -2436,13 +2437,13 @@ class CUsynchronizationPolicy(IntEnum):
 
     """
     {{if 'CU_SYNC_POLICY_AUTO' in found_values}}
-    CU_SYNC_POLICY_AUTO = ccuda.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_AUTO{{endif}}
+    CU_SYNC_POLICY_AUTO = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_AUTO{{endif}}
     {{if 'CU_SYNC_POLICY_SPIN' in found_values}}
-    CU_SYNC_POLICY_SPIN = ccuda.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_SPIN{{endif}}
+    CU_SYNC_POLICY_SPIN = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_SPIN{{endif}}
     {{if 'CU_SYNC_POLICY_YIELD' in found_values}}
-    CU_SYNC_POLICY_YIELD = ccuda.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_YIELD{{endif}}
+    CU_SYNC_POLICY_YIELD = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_YIELD{{endif}}
     {{if 'CU_SYNC_POLICY_BLOCKING_SYNC' in found_values}}
-    CU_SYNC_POLICY_BLOCKING_SYNC = ccuda.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_BLOCKING_SYNC{{endif}}
+    CU_SYNC_POLICY_BLOCKING_SYNC = cydriver.CUsynchronizationPolicy_enum.CU_SYNC_POLICY_BLOCKING_SYNC{{endif}}
 {{endif}}
 {{if 'CUclusterSchedulingPolicy_enum' in found_types}}
 
@@ -2454,16 +2455,16 @@ class CUclusterSchedulingPolicy(IntEnum):
     {{if 'CU_CLUSTER_SCHEDULING_POLICY_DEFAULT' in found_values}}
 
     #: the default policy
-    CU_CLUSTER_SCHEDULING_POLICY_DEFAULT = ccuda.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_DEFAULT{{endif}}
+    CU_CLUSTER_SCHEDULING_POLICY_DEFAULT = cydriver.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_DEFAULT{{endif}}
     {{if 'CU_CLUSTER_SCHEDULING_POLICY_SPREAD' in found_values}}
 
     #: spread the blocks within a cluster to the SMs
-    CU_CLUSTER_SCHEDULING_POLICY_SPREAD = ccuda.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_SPREAD{{endif}}
+    CU_CLUSTER_SCHEDULING_POLICY_SPREAD = cydriver.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_SPREAD{{endif}}
     {{if 'CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING' in found_values}}
 
     #: allow the hardware to load-balance the blocks in a cluster to the
     #: SMs
-    CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING = ccuda.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING{{endif}}
+    CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING = cydriver.CUclusterSchedulingPolicy_enum.CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING{{endif}}
 {{endif}}
 {{if 'CUlaunchAttributeID_enum' in found_types}}
 
@@ -2474,147 +2475,27 @@ class CUlaunchAttributeID(IntEnum):
     {{if 'CU_LAUNCH_ATTRIBUTE_IGNORE' in found_values}}
 
     #: Ignored entry, for convenient composition
-    CU_LAUNCH_ATTRIBUTE_IGNORE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW' in found_values}}
-
-    #: Valid for streams, graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_COOPERATIVE' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY' in found_values}}
-
-    #: Valid for streams.
-    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION' in found_values}}
-
-    #: Valid for launches. Setting programmaticStreamSerializationAllowed
-    #: to non-0 signals that the kernel will use programmatic means to
-    #: resolve its stream dependency, so that the CUDA runtime should
-    #: opportunistically allow the grid's execution to overlap with the
-    #: previous kernel in the stream, if that kernel requests the overlap.
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT' in found_values}}
-
-    #: Valid for launches. Event recorded through this launch attribute is
-    #: guaranteed to only trigger after all block in the associated kernel
-    #: trigger the event. A block can trigger the event through PTX
-    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
-    #: the beginning of each block's execution if triggerAtBlockStart is
-    #: set to non-0. Note that dependents (including the CPU thread calling
-    #: :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the
-    #: release precisely when it is released. For example,
-    #: :py:obj:`~.cuEventSynchronize()` may only observe the event trigger
-    #: long after the associated kernel has completed. This recording type
-    #: is primarily meant for establishing programmatic dependency between
-    #: device tasks. The event supplied must not be an interprocess or
-    #: interop event. The event must disable timing (i.e. created with
-    #: :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PRIORITY' in found_values}}
-
-    #: Valid for graph nodes.
-    CU_LAUNCH_ATTRIBUTE_PRIORITY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
-{{endif}}
-{{if 'CUlaunchAttributeID_enum' in found_types}}
-
-class CUkernelNodeAttrID(IntEnum):
-    """
-
-    """
-    {{if 'CU_LAUNCH_ATTRIBUTE_IGNORE' in found_values}}
-
-    #: Ignored entry, for convenient composition
-    CU_LAUNCH_ATTRIBUTE_IGNORE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW' in found_values}}
-
-    #: Valid for streams, graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_COOPERATIVE' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY' in found_values}}
-
-    #: Valid for streams.
-    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
-
-    #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION' in found_values}}
-
-    #: Valid for launches. Setting programmaticStreamSerializationAllowed
-    #: to non-0 signals that the kernel will use programmatic means to
-    #: resolve its stream dependency, so that the CUDA runtime should
-    #: opportunistically allow the grid's execution to overlap with the
-    #: previous kernel in the stream, if that kernel requests the overlap.
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT' in found_values}}
-
-    #: Valid for launches. Event recorded through this launch attribute is
-    #: guaranteed to only trigger after all block in the associated kernel
-    #: trigger the event. A block can trigger the event through PTX
-    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
-    #: the beginning of each block's execution if triggerAtBlockStart is
-    #: set to non-0. Note that dependents (including the CPU thread calling
-    #: :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the
-    #: release precisely when it is released. For example,
-    #: :py:obj:`~.cuEventSynchronize()` may only observe the event trigger
-    #: long after the associated kernel has completed. This recording type
-    #: is primarily meant for establishing programmatic dependency between
-    #: device tasks. The event supplied must not be an interprocess or
-    #: interop event. The event must disable timing (i.e. created with
-    #: :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
-    {{if 'CU_LAUNCH_ATTRIBUTE_PRIORITY' in found_values}}
-
-    #: Valid for graph nodes.
-    CU_LAUNCH_ATTRIBUTE_PRIORITY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
-{{endif}}
-{{if 'CUlaunchAttributeID_enum' in found_types}}
-
-class CUstreamAttrID(IntEnum):
-    """
-
-    """
-    {{if 'CU_LAUNCH_ATTRIBUTE_IGNORE' in found_values}}
-
-    #: Ignored entry, for convenient composition
-    CU_LAUNCH_ATTRIBUTE_IGNORE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
+    CU_LAUNCH_ATTRIBUTE_IGNORE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW' in found_values}}
 
     #: Valid for streams, graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
+    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_COOPERATIVE' in found_values}}
 
     #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
+    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY' in found_values}}
 
     #: Valid for streams.
-    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
+    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION' in found_values}}
 
     #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
 
     #: Valid for graph nodes, launches.
-    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION' in found_values}}
 
     #: Valid for launches. Setting programmaticStreamSerializationAllowed
@@ -2622,7 +2503,7 @@ class CUstreamAttrID(IntEnum):
     #: resolve its stream dependency, so that the CUDA runtime should
     #: opportunistically allow the grid's execution to overlap with the
     #: previous kernel in the stream, if that kernel requests the overlap.
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT' in found_values}}
 
     #: Valid for launches. Event recorded through this launch attribute is
@@ -2639,11 +2520,11 @@ class CUstreamAttrID(IntEnum):
     #: device tasks. The event supplied must not be an interprocess or
     #: interop event. The event must disable timing (i.e. created with
     #: :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
-    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
     {{if 'CU_LAUNCH_ATTRIBUTE_PRIORITY' in found_values}}
 
     #: Valid for graph nodes.
-    CU_LAUNCH_ATTRIBUTE_PRIORITY = ccuda.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
+    CU_LAUNCH_ATTRIBUTE_PRIORITY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
 {{endif}}
 {{if 'CUstreamCaptureStatus_enum' in found_types}}
 
@@ -2655,16 +2536,16 @@ class CUstreamCaptureStatus(IntEnum):
     {{if 'CU_STREAM_CAPTURE_STATUS_NONE' in found_values}}
 
     #: Stream is not capturing
-    CU_STREAM_CAPTURE_STATUS_NONE = ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_NONE{{endif}}
+    CU_STREAM_CAPTURE_STATUS_NONE = cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_NONE{{endif}}
     {{if 'CU_STREAM_CAPTURE_STATUS_ACTIVE' in found_values}}
 
     #: Stream is actively capturing
-    CU_STREAM_CAPTURE_STATUS_ACTIVE = ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_ACTIVE{{endif}}
+    CU_STREAM_CAPTURE_STATUS_ACTIVE = cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_ACTIVE{{endif}}
     {{if 'CU_STREAM_CAPTURE_STATUS_INVALIDATED' in found_values}}
 
     #: Stream is part of a capture sequence that has been invalidated, but
     #: not terminated
-    CU_STREAM_CAPTURE_STATUS_INVALIDATED = ccuda.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_INVALIDATED{{endif}}
+    CU_STREAM_CAPTURE_STATUS_INVALIDATED = cydriver.CUstreamCaptureStatus_enum.CU_STREAM_CAPTURE_STATUS_INVALIDATED{{endif}}
 {{endif}}
 {{if 'CUstreamCaptureMode_enum' in found_types}}
 
@@ -2675,11 +2556,11 @@ class CUstreamCaptureMode(IntEnum):
     :py:obj:`~.cuThreadExchangeStreamCaptureMode`
     """
     {{if 'CU_STREAM_CAPTURE_MODE_GLOBAL' in found_values}}
-    CU_STREAM_CAPTURE_MODE_GLOBAL = ccuda.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_GLOBAL{{endif}}
+    CU_STREAM_CAPTURE_MODE_GLOBAL = cydriver.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_GLOBAL{{endif}}
     {{if 'CU_STREAM_CAPTURE_MODE_THREAD_LOCAL' in found_values}}
-    CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = ccuda.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_THREAD_LOCAL{{endif}}
+    CU_STREAM_CAPTURE_MODE_THREAD_LOCAL = cydriver.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_THREAD_LOCAL{{endif}}
     {{if 'CU_STREAM_CAPTURE_MODE_RELAXED' in found_values}}
-    CU_STREAM_CAPTURE_MODE_RELAXED = ccuda.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_RELAXED{{endif}}
+    CU_STREAM_CAPTURE_MODE_RELAXED = cydriver.CUstreamCaptureMode_enum.CU_STREAM_CAPTURE_MODE_RELAXED{{endif}}
 {{endif}}
 {{if 'CUdriverProcAddress_flags_enum' in found_types}}
 
@@ -2691,15 +2572,15 @@ class CUdriverProcAddress_flags(IntEnum):
     {{if 'CU_GET_PROC_ADDRESS_DEFAULT' in found_values}}
 
     #: Default search mode for driver symbols.
-    CU_GET_PROC_ADDRESS_DEFAULT = ccuda.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_DEFAULT{{endif}}
+    CU_GET_PROC_ADDRESS_DEFAULT = cydriver.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_DEFAULT{{endif}}
     {{if 'CU_GET_PROC_ADDRESS_LEGACY_STREAM' in found_values}}
 
     #: Search for legacy versions of driver symbols.
-    CU_GET_PROC_ADDRESS_LEGACY_STREAM = ccuda.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_LEGACY_STREAM{{endif}}
+    CU_GET_PROC_ADDRESS_LEGACY_STREAM = cydriver.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_LEGACY_STREAM{{endif}}
     {{if 'CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM' in found_values}}
 
     #: Search for per-thread versions of driver symbols.
-    CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = ccuda.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM{{endif}}
+    CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM = cydriver.CUdriverProcAddress_flags_enum.CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM{{endif}}
 {{endif}}
 {{if 'CUexecAffinityType_enum' in found_types}}
 
@@ -2710,9 +2591,9 @@ class CUexecAffinityType(IntEnum):
     {{if 'CU_EXEC_AFFINITY_TYPE_SM_COUNT' in found_values}}
 
     #: Create a context with limited SMs.
-    CU_EXEC_AFFINITY_TYPE_SM_COUNT = ccuda.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_SM_COUNT{{endif}}
+    CU_EXEC_AFFINITY_TYPE_SM_COUNT = cydriver.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_SM_COUNT{{endif}}
     {{if 'CU_EXEC_AFFINITY_TYPE_MAX' in found_values}}
-    CU_EXEC_AFFINITY_TYPE_MAX = ccuda.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_MAX{{endif}}
+    CU_EXEC_AFFINITY_TYPE_MAX = cydriver.CUexecAffinityType_enum.CU_EXEC_AFFINITY_TYPE_MAX{{endif}}
 {{endif}}
 {{if 'cudaError_enum' in found_types}}
 
@@ -2725,78 +2606,78 @@ class CUresult(IntEnum):
     #: The API call returned with no errors. In the case of query calls,
     #: this also means that the operation being queried is complete (see
     #: :py:obj:`~.cuEventQuery()` and :py:obj:`~.cuStreamQuery()`).
-    CUDA_SUCCESS = ccuda.cudaError_enum.CUDA_SUCCESS{{endif}}
+    CUDA_SUCCESS = cydriver.cudaError_enum.CUDA_SUCCESS{{endif}}
     {{if 'CUDA_ERROR_INVALID_VALUE' in found_values}}
 
     #: This indicates that one or more of the parameters passed to the API
     #: call is not within an acceptable range of values.
-    CUDA_ERROR_INVALID_VALUE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_VALUE{{endif}}
+    CUDA_ERROR_INVALID_VALUE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_VALUE{{endif}}
     {{if 'CUDA_ERROR_OUT_OF_MEMORY' in found_values}}
 
     #: The API call failed because it was unable to allocate enough memory
     #: to perform the requested operation.
-    CUDA_ERROR_OUT_OF_MEMORY = ccuda.cudaError_enum.CUDA_ERROR_OUT_OF_MEMORY{{endif}}
+    CUDA_ERROR_OUT_OF_MEMORY = cydriver.cudaError_enum.CUDA_ERROR_OUT_OF_MEMORY{{endif}}
     {{if 'CUDA_ERROR_NOT_INITIALIZED' in found_values}}
 
     #: This indicates that the CUDA driver has not been initialized with
     #: :py:obj:`~.cuInit()` or that initialization has failed.
-    CUDA_ERROR_NOT_INITIALIZED = ccuda.cudaError_enum.CUDA_ERROR_NOT_INITIALIZED{{endif}}
+    CUDA_ERROR_NOT_INITIALIZED = cydriver.cudaError_enum.CUDA_ERROR_NOT_INITIALIZED{{endif}}
     {{if 'CUDA_ERROR_DEINITIALIZED' in found_values}}
 
     #: This indicates that the CUDA driver is in the process of shutting
     #: down.
-    CUDA_ERROR_DEINITIALIZED = ccuda.cudaError_enum.CUDA_ERROR_DEINITIALIZED{{endif}}
+    CUDA_ERROR_DEINITIALIZED = cydriver.cudaError_enum.CUDA_ERROR_DEINITIALIZED{{endif}}
     {{if 'CUDA_ERROR_PROFILER_DISABLED' in found_values}}
 
     #: This indicates profiler is not initialized for this run. This can
     #: happen when the application is running with external profiling tools
     #: like visual profiler.
-    CUDA_ERROR_PROFILER_DISABLED = ccuda.cudaError_enum.CUDA_ERROR_PROFILER_DISABLED{{endif}}
+    CUDA_ERROR_PROFILER_DISABLED = cydriver.cudaError_enum.CUDA_ERROR_PROFILER_DISABLED{{endif}}
     {{if 'CUDA_ERROR_PROFILER_NOT_INITIALIZED' in found_values}}
 
     #: [Deprecated]
-    CUDA_ERROR_PROFILER_NOT_INITIALIZED = ccuda.cudaError_enum.CUDA_ERROR_PROFILER_NOT_INITIALIZED{{endif}}
+    CUDA_ERROR_PROFILER_NOT_INITIALIZED = cydriver.cudaError_enum.CUDA_ERROR_PROFILER_NOT_INITIALIZED{{endif}}
     {{if 'CUDA_ERROR_PROFILER_ALREADY_STARTED' in found_values}}
 
     #: [Deprecated]
-    CUDA_ERROR_PROFILER_ALREADY_STARTED = ccuda.cudaError_enum.CUDA_ERROR_PROFILER_ALREADY_STARTED{{endif}}
+    CUDA_ERROR_PROFILER_ALREADY_STARTED = cydriver.cudaError_enum.CUDA_ERROR_PROFILER_ALREADY_STARTED{{endif}}
     {{if 'CUDA_ERROR_PROFILER_ALREADY_STOPPED' in found_values}}
 
     #: [Deprecated]
-    CUDA_ERROR_PROFILER_ALREADY_STOPPED = ccuda.cudaError_enum.CUDA_ERROR_PROFILER_ALREADY_STOPPED{{endif}}
+    CUDA_ERROR_PROFILER_ALREADY_STOPPED = cydriver.cudaError_enum.CUDA_ERROR_PROFILER_ALREADY_STOPPED{{endif}}
     {{if 'CUDA_ERROR_STUB_LIBRARY' in found_values}}
 
     #: This indicates that the CUDA driver that the application has loaded
     #: is a stub library. Applications that run with the stub rather than a
     #: real driver loaded will result in CUDA API returning this error.
-    CUDA_ERROR_STUB_LIBRARY = ccuda.cudaError_enum.CUDA_ERROR_STUB_LIBRARY{{endif}}
+    CUDA_ERROR_STUB_LIBRARY = cydriver.cudaError_enum.CUDA_ERROR_STUB_LIBRARY{{endif}}
     {{if 'CUDA_ERROR_DEVICE_UNAVAILABLE' in found_values}}
 
     #: This indicates that requested CUDA device is unavailable at the
     #: current time. Devices are often unavailable due to use of
     #: :py:obj:`~.CU_COMPUTEMODE_EXCLUSIVE_PROCESS` or
     #: :py:obj:`~.CU_COMPUTEMODE_PROHIBITED`.
-    CUDA_ERROR_DEVICE_UNAVAILABLE = ccuda.cudaError_enum.CUDA_ERROR_DEVICE_UNAVAILABLE{{endif}}
+    CUDA_ERROR_DEVICE_UNAVAILABLE = cydriver.cudaError_enum.CUDA_ERROR_DEVICE_UNAVAILABLE{{endif}}
     {{if 'CUDA_ERROR_NO_DEVICE' in found_values}}
 
     #: This indicates that no CUDA-capable devices were detected by the
     #: installed CUDA driver.
-    CUDA_ERROR_NO_DEVICE = ccuda.cudaError_enum.CUDA_ERROR_NO_DEVICE{{endif}}
+    CUDA_ERROR_NO_DEVICE = cydriver.cudaError_enum.CUDA_ERROR_NO_DEVICE{{endif}}
     {{if 'CUDA_ERROR_INVALID_DEVICE' in found_values}}
 
     #: This indicates that the device ordinal supplied by the user does not
     #: correspond to a valid CUDA device or that the action requested is
     #: invalid for the specified device.
-    CUDA_ERROR_INVALID_DEVICE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_DEVICE{{endif}}
+    CUDA_ERROR_INVALID_DEVICE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_DEVICE{{endif}}
     {{if 'CUDA_ERROR_DEVICE_NOT_LICENSED' in found_values}}
 
     #: This error indicates that the Grid license is not applied.
-    CUDA_ERROR_DEVICE_NOT_LICENSED = ccuda.cudaError_enum.CUDA_ERROR_DEVICE_NOT_LICENSED{{endif}}
+    CUDA_ERROR_DEVICE_NOT_LICENSED = cydriver.cudaError_enum.CUDA_ERROR_DEVICE_NOT_LICENSED{{endif}}
     {{if 'CUDA_ERROR_INVALID_IMAGE' in found_values}}
 
     #: This indicates that the device kernel image is invalid. This can
     #: also indicate an invalid CUDA module.
-    CUDA_ERROR_INVALID_IMAGE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_IMAGE{{endif}}
+    CUDA_ERROR_INVALID_IMAGE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_IMAGE{{endif}}
     {{if 'CUDA_ERROR_INVALID_CONTEXT' in found_values}}
 
     #: This most frequently indicates that there is no context bound to the
@@ -2805,145 +2686,145 @@ class CUresult(IntEnum):
     #: :py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned
     #: if a user mixes different API versions (i.e. 3010 context with 3020
     #: API calls). See :py:obj:`~.cuCtxGetApiVersion()` for more details.
-    CUDA_ERROR_INVALID_CONTEXT = ccuda.cudaError_enum.CUDA_ERROR_INVALID_CONTEXT{{endif}}
+    CUDA_ERROR_INVALID_CONTEXT = cydriver.cudaError_enum.CUDA_ERROR_INVALID_CONTEXT{{endif}}
     {{if 'CUDA_ERROR_CONTEXT_ALREADY_CURRENT' in found_values}}
 
     #: This indicated that the context being supplied as a parameter to the
     #: API call was already the active context. [Deprecated]
-    CUDA_ERROR_CONTEXT_ALREADY_CURRENT = ccuda.cudaError_enum.CUDA_ERROR_CONTEXT_ALREADY_CURRENT{{endif}}
+    CUDA_ERROR_CONTEXT_ALREADY_CURRENT = cydriver.cudaError_enum.CUDA_ERROR_CONTEXT_ALREADY_CURRENT{{endif}}
     {{if 'CUDA_ERROR_MAP_FAILED' in found_values}}
 
     #: This indicates that a map or register operation has failed.
-    CUDA_ERROR_MAP_FAILED = ccuda.cudaError_enum.CUDA_ERROR_MAP_FAILED{{endif}}
+    CUDA_ERROR_MAP_FAILED = cydriver.cudaError_enum.CUDA_ERROR_MAP_FAILED{{endif}}
     {{if 'CUDA_ERROR_UNMAP_FAILED' in found_values}}
 
     #: This indicates that an unmap or unregister operation has failed.
-    CUDA_ERROR_UNMAP_FAILED = ccuda.cudaError_enum.CUDA_ERROR_UNMAP_FAILED{{endif}}
+    CUDA_ERROR_UNMAP_FAILED = cydriver.cudaError_enum.CUDA_ERROR_UNMAP_FAILED{{endif}}
     {{if 'CUDA_ERROR_ARRAY_IS_MAPPED' in found_values}}
 
     #: This indicates that the specified array is currently mapped and thus
     #: cannot be destroyed.
-    CUDA_ERROR_ARRAY_IS_MAPPED = ccuda.cudaError_enum.CUDA_ERROR_ARRAY_IS_MAPPED{{endif}}
+    CUDA_ERROR_ARRAY_IS_MAPPED = cydriver.cudaError_enum.CUDA_ERROR_ARRAY_IS_MAPPED{{endif}}
     {{if 'CUDA_ERROR_ALREADY_MAPPED' in found_values}}
 
     #: This indicates that the resource is already mapped.
-    CUDA_ERROR_ALREADY_MAPPED = ccuda.cudaError_enum.CUDA_ERROR_ALREADY_MAPPED{{endif}}
+    CUDA_ERROR_ALREADY_MAPPED = cydriver.cudaError_enum.CUDA_ERROR_ALREADY_MAPPED{{endif}}
     {{if 'CUDA_ERROR_NO_BINARY_FOR_GPU' in found_values}}
 
     #: This indicates that there is no kernel image available that is
     #: suitable for the device. This can occur when a user specifies code
     #: generation options for a particular CUDA source file that do not
     #: include the corresponding device configuration.
-    CUDA_ERROR_NO_BINARY_FOR_GPU = ccuda.cudaError_enum.CUDA_ERROR_NO_BINARY_FOR_GPU{{endif}}
+    CUDA_ERROR_NO_BINARY_FOR_GPU = cydriver.cudaError_enum.CUDA_ERROR_NO_BINARY_FOR_GPU{{endif}}
     {{if 'CUDA_ERROR_ALREADY_ACQUIRED' in found_values}}
 
     #: This indicates that a resource has already been acquired.
-    CUDA_ERROR_ALREADY_ACQUIRED = ccuda.cudaError_enum.CUDA_ERROR_ALREADY_ACQUIRED{{endif}}
+    CUDA_ERROR_ALREADY_ACQUIRED = cydriver.cudaError_enum.CUDA_ERROR_ALREADY_ACQUIRED{{endif}}
     {{if 'CUDA_ERROR_NOT_MAPPED' in found_values}}
 
     #: This indicates that a resource is not mapped.
-    CUDA_ERROR_NOT_MAPPED = ccuda.cudaError_enum.CUDA_ERROR_NOT_MAPPED{{endif}}
+    CUDA_ERROR_NOT_MAPPED = cydriver.cudaError_enum.CUDA_ERROR_NOT_MAPPED{{endif}}
     {{if 'CUDA_ERROR_NOT_MAPPED_AS_ARRAY' in found_values}}
 
     #: This indicates that a mapped resource is not available for access as
     #: an array.
-    CUDA_ERROR_NOT_MAPPED_AS_ARRAY = ccuda.cudaError_enum.CUDA_ERROR_NOT_MAPPED_AS_ARRAY{{endif}}
+    CUDA_ERROR_NOT_MAPPED_AS_ARRAY = cydriver.cudaError_enum.CUDA_ERROR_NOT_MAPPED_AS_ARRAY{{endif}}
     {{if 'CUDA_ERROR_NOT_MAPPED_AS_POINTER' in found_values}}
 
     #: This indicates that a mapped resource is not available for access as
     #: a pointer.
-    CUDA_ERROR_NOT_MAPPED_AS_POINTER = ccuda.cudaError_enum.CUDA_ERROR_NOT_MAPPED_AS_POINTER{{endif}}
+    CUDA_ERROR_NOT_MAPPED_AS_POINTER = cydriver.cudaError_enum.CUDA_ERROR_NOT_MAPPED_AS_POINTER{{endif}}
     {{if 'CUDA_ERROR_ECC_UNCORRECTABLE' in found_values}}
 
     #: This indicates that an uncorrectable ECC error was detected during
     #: execution.
-    CUDA_ERROR_ECC_UNCORRECTABLE = ccuda.cudaError_enum.CUDA_ERROR_ECC_UNCORRECTABLE{{endif}}
+    CUDA_ERROR_ECC_UNCORRECTABLE = cydriver.cudaError_enum.CUDA_ERROR_ECC_UNCORRECTABLE{{endif}}
     {{if 'CUDA_ERROR_UNSUPPORTED_LIMIT' in found_values}}
 
     #: This indicates that the :py:obj:`~.CUlimit` passed to the API call
     #: is not supported by the active device.
-    CUDA_ERROR_UNSUPPORTED_LIMIT = ccuda.cudaError_enum.CUDA_ERROR_UNSUPPORTED_LIMIT{{endif}}
+    CUDA_ERROR_UNSUPPORTED_LIMIT = cydriver.cudaError_enum.CUDA_ERROR_UNSUPPORTED_LIMIT{{endif}}
     {{if 'CUDA_ERROR_CONTEXT_ALREADY_IN_USE' in found_values}}
 
     #: This indicates that the :py:obj:`~.CUcontext` passed to the API call
     #: can only be bound to a single CPU thread at a time but is already
     #: bound to a CPU thread.
-    CUDA_ERROR_CONTEXT_ALREADY_IN_USE = ccuda.cudaError_enum.CUDA_ERROR_CONTEXT_ALREADY_IN_USE{{endif}}
+    CUDA_ERROR_CONTEXT_ALREADY_IN_USE = cydriver.cudaError_enum.CUDA_ERROR_CONTEXT_ALREADY_IN_USE{{endif}}
     {{if 'CUDA_ERROR_PEER_ACCESS_UNSUPPORTED' in found_values}}
 
     #: This indicates that peer access is not supported across the given
     #: devices.
-    CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = ccuda.cudaError_enum.CUDA_ERROR_PEER_ACCESS_UNSUPPORTED{{endif}}
+    CUDA_ERROR_PEER_ACCESS_UNSUPPORTED = cydriver.cudaError_enum.CUDA_ERROR_PEER_ACCESS_UNSUPPORTED{{endif}}
     {{if 'CUDA_ERROR_INVALID_PTX' in found_values}}
 
     #: This indicates that a PTX JIT compilation failed.
-    CUDA_ERROR_INVALID_PTX = ccuda.cudaError_enum.CUDA_ERROR_INVALID_PTX{{endif}}
+    CUDA_ERROR_INVALID_PTX = cydriver.cudaError_enum.CUDA_ERROR_INVALID_PTX{{endif}}
     {{if 'CUDA_ERROR_INVALID_GRAPHICS_CONTEXT' in found_values}}
 
     #: This indicates an error with OpenGL or DirectX context.
-    CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = ccuda.cudaError_enum.CUDA_ERROR_INVALID_GRAPHICS_CONTEXT{{endif}}
+    CUDA_ERROR_INVALID_GRAPHICS_CONTEXT = cydriver.cudaError_enum.CUDA_ERROR_INVALID_GRAPHICS_CONTEXT{{endif}}
     {{if 'CUDA_ERROR_NVLINK_UNCORRECTABLE' in found_values}}
 
     #: This indicates that an uncorrectable NVLink error was detected
     #: during the execution.
-    CUDA_ERROR_NVLINK_UNCORRECTABLE = ccuda.cudaError_enum.CUDA_ERROR_NVLINK_UNCORRECTABLE{{endif}}
+    CUDA_ERROR_NVLINK_UNCORRECTABLE = cydriver.cudaError_enum.CUDA_ERROR_NVLINK_UNCORRECTABLE{{endif}}
     {{if 'CUDA_ERROR_JIT_COMPILER_NOT_FOUND' in found_values}}
 
     #: This indicates that the PTX JIT compiler library was not found.
-    CUDA_ERROR_JIT_COMPILER_NOT_FOUND = ccuda.cudaError_enum.CUDA_ERROR_JIT_COMPILER_NOT_FOUND{{endif}}
+    CUDA_ERROR_JIT_COMPILER_NOT_FOUND = cydriver.cudaError_enum.CUDA_ERROR_JIT_COMPILER_NOT_FOUND{{endif}}
     {{if 'CUDA_ERROR_UNSUPPORTED_PTX_VERSION' in found_values}}
 
     #: This indicates that the provided PTX was compiled with an
     #: unsupported toolchain.
-    CUDA_ERROR_UNSUPPORTED_PTX_VERSION = ccuda.cudaError_enum.CUDA_ERROR_UNSUPPORTED_PTX_VERSION{{endif}}
+    CUDA_ERROR_UNSUPPORTED_PTX_VERSION = cydriver.cudaError_enum.CUDA_ERROR_UNSUPPORTED_PTX_VERSION{{endif}}
     {{if 'CUDA_ERROR_JIT_COMPILATION_DISABLED' in found_values}}
 
     #: This indicates that the PTX JIT compilation was disabled.
-    CUDA_ERROR_JIT_COMPILATION_DISABLED = ccuda.cudaError_enum.CUDA_ERROR_JIT_COMPILATION_DISABLED{{endif}}
+    CUDA_ERROR_JIT_COMPILATION_DISABLED = cydriver.cudaError_enum.CUDA_ERROR_JIT_COMPILATION_DISABLED{{endif}}
     {{if 'CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY' in found_values}}
 
     #: This indicates that the :py:obj:`~.CUexecAffinityType` passed to the
     #: API call is not supported by the active device.
-    CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY = ccuda.cudaError_enum.CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY{{endif}}
+    CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY = cydriver.cudaError_enum.CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY{{endif}}
     {{if 'CUDA_ERROR_INVALID_SOURCE' in found_values}}
 
     #: This indicates that the device kernel source is invalid. This
     #: includes compilation/linker errors encountered in device code or
     #: user error.
-    CUDA_ERROR_INVALID_SOURCE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_SOURCE{{endif}}
+    CUDA_ERROR_INVALID_SOURCE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_SOURCE{{endif}}
     {{if 'CUDA_ERROR_FILE_NOT_FOUND' in found_values}}
 
     #: This indicates that the file specified was not found.
-    CUDA_ERROR_FILE_NOT_FOUND = ccuda.cudaError_enum.CUDA_ERROR_FILE_NOT_FOUND{{endif}}
+    CUDA_ERROR_FILE_NOT_FOUND = cydriver.cudaError_enum.CUDA_ERROR_FILE_NOT_FOUND{{endif}}
     {{if 'CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND' in found_values}}
 
     #: This indicates that a link to a shared object failed to resolve.
-    CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = ccuda.cudaError_enum.CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND{{endif}}
+    CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND = cydriver.cudaError_enum.CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND{{endif}}
     {{if 'CUDA_ERROR_SHARED_OBJECT_INIT_FAILED' in found_values}}
 
     #: This indicates that initialization of a shared object failed.
-    CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = ccuda.cudaError_enum.CUDA_ERROR_SHARED_OBJECT_INIT_FAILED{{endif}}
+    CUDA_ERROR_SHARED_OBJECT_INIT_FAILED = cydriver.cudaError_enum.CUDA_ERROR_SHARED_OBJECT_INIT_FAILED{{endif}}
     {{if 'CUDA_ERROR_OPERATING_SYSTEM' in found_values}}
 
     #: This indicates that an OS call failed.
-    CUDA_ERROR_OPERATING_SYSTEM = ccuda.cudaError_enum.CUDA_ERROR_OPERATING_SYSTEM{{endif}}
+    CUDA_ERROR_OPERATING_SYSTEM = cydriver.cudaError_enum.CUDA_ERROR_OPERATING_SYSTEM{{endif}}
     {{if 'CUDA_ERROR_INVALID_HANDLE' in found_values}}
 
     #: This indicates that a resource handle passed to the API call was not
     #: valid. Resource handles are opaque types like :py:obj:`~.CUstream`
     #: and :py:obj:`~.CUevent`.
-    CUDA_ERROR_INVALID_HANDLE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_HANDLE{{endif}}
+    CUDA_ERROR_INVALID_HANDLE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_HANDLE{{endif}}
     {{if 'CUDA_ERROR_ILLEGAL_STATE' in found_values}}
 
     #: This indicates that a resource required by the API call is not in a
     #: valid state to perform the requested operation.
-    CUDA_ERROR_ILLEGAL_STATE = ccuda.cudaError_enum.CUDA_ERROR_ILLEGAL_STATE{{endif}}
+    CUDA_ERROR_ILLEGAL_STATE = cydriver.cudaError_enum.CUDA_ERROR_ILLEGAL_STATE{{endif}}
     {{if 'CUDA_ERROR_NOT_FOUND' in found_values}}
 
     #: This indicates that a named symbol was not found. Examples of
     #: symbols are global/constant variable names, driver function names,
     #: texture names, and surface names.
-    CUDA_ERROR_NOT_FOUND = ccuda.cudaError_enum.CUDA_ERROR_NOT_FOUND{{endif}}
+    CUDA_ERROR_NOT_FOUND = cydriver.cudaError_enum.CUDA_ERROR_NOT_FOUND{{endif}}
     {{if 'CUDA_ERROR_NOT_READY' in found_values}}
 
     #: This indicates that asynchronous operations issued previously have
@@ -2951,7 +2832,7 @@ class CUresult(IntEnum):
     #: indicated differently than :py:obj:`~.CUDA_SUCCESS` (which indicates
     #: completion). Calls that may return this value include
     #: :py:obj:`~.cuEventQuery()` and :py:obj:`~.cuStreamQuery()`.
-    CUDA_ERROR_NOT_READY = ccuda.cudaError_enum.CUDA_ERROR_NOT_READY{{endif}}
+    CUDA_ERROR_NOT_READY = cydriver.cudaError_enum.CUDA_ERROR_NOT_READY{{endif}}
     {{if 'CUDA_ERROR_ILLEGAL_ADDRESS' in found_values}}
 
     #: While executing a kernel, the device encountered a load or store
@@ -2959,7 +2840,7 @@ class CUresult(IntEnum):
     #: an inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    CUDA_ERROR_ILLEGAL_ADDRESS = ccuda.cudaError_enum.CUDA_ERROR_ILLEGAL_ADDRESS{{endif}}
+    CUDA_ERROR_ILLEGAL_ADDRESS = cydriver.cudaError_enum.CUDA_ERROR_ILLEGAL_ADDRESS{{endif}}
     {{if 'CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES' in found_values}}
 
     #: This indicates that a launch did not occur because it did not have
@@ -2969,7 +2850,7 @@ class CUresult(IntEnum):
     #: register count. Passing arguments of the wrong size (i.e. a 64-bit
     #: pointer when a 32-bit int is expected) is equivalent to passing too
     #: many arguments and can also result in this error.
-    CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = ccuda.cudaError_enum.CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES{{endif}}
+    CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = cydriver.cudaError_enum.CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES{{endif}}
     {{if 'CUDA_ERROR_LAUNCH_TIMEOUT' in found_values}}
 
     #: This indicates that the device kernel took too long to execute. This
@@ -2978,59 +2859,59 @@ class CUresult(IntEnum):
     #: information. This leaves the process in an inconsistent state and
     #: any further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    CUDA_ERROR_LAUNCH_TIMEOUT = ccuda.cudaError_enum.CUDA_ERROR_LAUNCH_TIMEOUT{{endif}}
+    CUDA_ERROR_LAUNCH_TIMEOUT = cydriver.cudaError_enum.CUDA_ERROR_LAUNCH_TIMEOUT{{endif}}
     {{if 'CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING' in found_values}}
 
     #: This error indicates a kernel launch that uses an incompatible
     #: texturing mode.
-    CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = ccuda.cudaError_enum.CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING{{endif}}
+    CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = cydriver.cudaError_enum.CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING{{endif}}
     {{if 'CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED' in found_values}}
 
     #: This error indicates that a call to
     #: :py:obj:`~.cuCtxEnablePeerAccess()` is trying to re-enable peer
     #: access to a context which has already had peer access to it enabled.
-    CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = ccuda.cudaError_enum.CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED{{endif}}
+    CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED = cydriver.cudaError_enum.CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED{{endif}}
     {{if 'CUDA_ERROR_PEER_ACCESS_NOT_ENABLED' in found_values}}
 
     #: This error indicates that :py:obj:`~.cuCtxDisablePeerAccess()` is
     #: trying to disable peer access which has not been enabled yet via
     #: :py:obj:`~.cuCtxEnablePeerAccess()`.
-    CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = ccuda.cudaError_enum.CUDA_ERROR_PEER_ACCESS_NOT_ENABLED{{endif}}
+    CUDA_ERROR_PEER_ACCESS_NOT_ENABLED = cydriver.cudaError_enum.CUDA_ERROR_PEER_ACCESS_NOT_ENABLED{{endif}}
     {{if 'CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE' in found_values}}
 
     #: This error indicates that the primary context for the specified
     #: device has already been initialized.
-    CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = ccuda.cudaError_enum.CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE{{endif}}
+    CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE = cydriver.cudaError_enum.CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE{{endif}}
     {{if 'CUDA_ERROR_CONTEXT_IS_DESTROYED' in found_values}}
 
     #: This error indicates that the context current to the calling thread
     #: has been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary
     #: context which has not yet been initialized.
-    CUDA_ERROR_CONTEXT_IS_DESTROYED = ccuda.cudaError_enum.CUDA_ERROR_CONTEXT_IS_DESTROYED{{endif}}
+    CUDA_ERROR_CONTEXT_IS_DESTROYED = cydriver.cudaError_enum.CUDA_ERROR_CONTEXT_IS_DESTROYED{{endif}}
     {{if 'CUDA_ERROR_ASSERT' in found_values}}
 
     #: A device-side assert triggered during kernel execution. The context
     #: cannot be used anymore, and must be destroyed. All existing device
     #: memory allocations from this context are invalid and must be
     #: reconstructed if the program is to continue using CUDA.
-    CUDA_ERROR_ASSERT = ccuda.cudaError_enum.CUDA_ERROR_ASSERT{{endif}}
+    CUDA_ERROR_ASSERT = cydriver.cudaError_enum.CUDA_ERROR_ASSERT{{endif}}
     {{if 'CUDA_ERROR_TOO_MANY_PEERS' in found_values}}
 
     #: This error indicates that the hardware resources required to enable
     #: peer access have been exhausted for one or more of the devices
     #: passed to :py:obj:`~.cuCtxEnablePeerAccess()`.
-    CUDA_ERROR_TOO_MANY_PEERS = ccuda.cudaError_enum.CUDA_ERROR_TOO_MANY_PEERS{{endif}}
+    CUDA_ERROR_TOO_MANY_PEERS = cydriver.cudaError_enum.CUDA_ERROR_TOO_MANY_PEERS{{endif}}
     {{if 'CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED' in found_values}}
 
     #: This error indicates that the memory range passed to
     #: :py:obj:`~.cuMemHostRegister()` has already been registered.
-    CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = ccuda.cudaError_enum.CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED{{endif}}
+    CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED = cydriver.cudaError_enum.CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED{{endif}}
     {{if 'CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED' in found_values}}
 
     #: This error indicates that the pointer passed to
     #: :py:obj:`~.cuMemHostUnregister()` does not correspond to any
     #: currently registered memory region.
-    CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = ccuda.cudaError_enum.CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED{{endif}}
+    CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED = cydriver.cudaError_enum.CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED{{endif}}
     {{if 'CUDA_ERROR_HARDWARE_STACK_ERROR' in found_values}}
 
     #: While executing a kernel, the device encountered a stack error. This
@@ -3038,14 +2919,14 @@ class CUresult(IntEnum):
     #: This leaves the process in an inconsistent state and any further
     #: CUDA work will return the same error. To continue using CUDA, the
     #: process must be terminated and relaunched.
-    CUDA_ERROR_HARDWARE_STACK_ERROR = ccuda.cudaError_enum.CUDA_ERROR_HARDWARE_STACK_ERROR{{endif}}
+    CUDA_ERROR_HARDWARE_STACK_ERROR = cydriver.cudaError_enum.CUDA_ERROR_HARDWARE_STACK_ERROR{{endif}}
     {{if 'CUDA_ERROR_ILLEGAL_INSTRUCTION' in found_values}}
 
     #: While executing a kernel, the device encountered an illegal
     #: instruction. This leaves the process in an inconsistent state and
     #: any further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    CUDA_ERROR_ILLEGAL_INSTRUCTION = ccuda.cudaError_enum.CUDA_ERROR_ILLEGAL_INSTRUCTION{{endif}}
+    CUDA_ERROR_ILLEGAL_INSTRUCTION = cydriver.cudaError_enum.CUDA_ERROR_ILLEGAL_INSTRUCTION{{endif}}
     {{if 'CUDA_ERROR_MISALIGNED_ADDRESS' in found_values}}
 
     #: While executing a kernel, the device encountered a load or store
@@ -3053,7 +2934,7 @@ class CUresult(IntEnum):
     #: the process in an inconsistent state and any further CUDA work will
     #: return the same error. To continue using CUDA, the process must be
     #: terminated and relaunched.
-    CUDA_ERROR_MISALIGNED_ADDRESS = ccuda.cudaError_enum.CUDA_ERROR_MISALIGNED_ADDRESS{{endif}}
+    CUDA_ERROR_MISALIGNED_ADDRESS = cydriver.cudaError_enum.CUDA_ERROR_MISALIGNED_ADDRESS{{endif}}
     {{if 'CUDA_ERROR_INVALID_ADDRESS_SPACE' in found_values}}
 
     #: While executing a kernel, the device encountered an instruction
@@ -3063,14 +2944,14 @@ class CUresult(IntEnum):
     #: inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    CUDA_ERROR_INVALID_ADDRESS_SPACE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_ADDRESS_SPACE{{endif}}
+    CUDA_ERROR_INVALID_ADDRESS_SPACE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_ADDRESS_SPACE{{endif}}
     {{if 'CUDA_ERROR_INVALID_PC' in found_values}}
 
     #: While executing a kernel, the device program counter wrapped its
     #: address space. This leaves the process in an inconsistent state and
     #: any further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    CUDA_ERROR_INVALID_PC = ccuda.cudaError_enum.CUDA_ERROR_INVALID_PC{{endif}}
+    CUDA_ERROR_INVALID_PC = cydriver.cudaError_enum.CUDA_ERROR_INVALID_PC{{endif}}
     {{if 'CUDA_ERROR_LAUNCH_FAILED' in found_values}}
 
     #: An exception occurred on the device while executing a kernel. Common
@@ -3081,7 +2962,7 @@ class CUresult(IntEnum):
     #: inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    CUDA_ERROR_LAUNCH_FAILED = ccuda.cudaError_enum.CUDA_ERROR_LAUNCH_FAILED{{endif}}
+    CUDA_ERROR_LAUNCH_FAILED = cydriver.cudaError_enum.CUDA_ERROR_LAUNCH_FAILED{{endif}}
     {{if 'CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE' in found_values}}
 
     #: This error indicates that the number of blocks launched per grid for
@@ -3093,16 +2974,16 @@ class CUresult(IntEnum):
     #: :py:obj:`~.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`
     #: times the number of multiprocessors as specified by the device
     #: attribute :py:obj:`~.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT`.
-    CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = ccuda.cudaError_enum.CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE{{endif}}
+    CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE = cydriver.cudaError_enum.CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE{{endif}}
     {{if 'CUDA_ERROR_NOT_PERMITTED' in found_values}}
 
     #: This error indicates that the attempted operation is not permitted.
-    CUDA_ERROR_NOT_PERMITTED = ccuda.cudaError_enum.CUDA_ERROR_NOT_PERMITTED{{endif}}
+    CUDA_ERROR_NOT_PERMITTED = cydriver.cudaError_enum.CUDA_ERROR_NOT_PERMITTED{{endif}}
     {{if 'CUDA_ERROR_NOT_SUPPORTED' in found_values}}
 
     #: This error indicates that the attempted operation is not supported
     #: on the current system or device.
-    CUDA_ERROR_NOT_SUPPORTED = ccuda.cudaError_enum.CUDA_ERROR_NOT_SUPPORTED{{endif}}
+    CUDA_ERROR_NOT_SUPPORTED = cydriver.cudaError_enum.CUDA_ERROR_NOT_SUPPORTED{{endif}}
     {{if 'CUDA_ERROR_SYSTEM_NOT_READY' in found_values}}
 
     #: This error indicates that the system is not yet ready to start any
@@ -3110,13 +2991,13 @@ class CUresult(IntEnum):
     #: is in a valid state and all required driver daemons are actively
     #: running. More information about this error can be found in the
     #: system specific user guide.
-    CUDA_ERROR_SYSTEM_NOT_READY = ccuda.cudaError_enum.CUDA_ERROR_SYSTEM_NOT_READY{{endif}}
+    CUDA_ERROR_SYSTEM_NOT_READY = cydriver.cudaError_enum.CUDA_ERROR_SYSTEM_NOT_READY{{endif}}
     {{if 'CUDA_ERROR_SYSTEM_DRIVER_MISMATCH' in found_values}}
 
     #: This error indicates that there is a mismatch between the versions
     #: of the display driver and the CUDA driver. Refer to the
     #: compatibility documentation for supported versions.
-    CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = ccuda.cudaError_enum.CUDA_ERROR_SYSTEM_DRIVER_MISMATCH{{endif}}
+    CUDA_ERROR_SYSTEM_DRIVER_MISMATCH = cydriver.cudaError_enum.CUDA_ERROR_SYSTEM_DRIVER_MISMATCH{{endif}}
     {{if 'CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE' in found_values}}
 
     #: This error indicates that the system was upgraded to run with
@@ -3125,98 +3006,98 @@ class CUresult(IntEnum):
     #: documentation for the supported hardware matrix or ensure that only
     #: supported hardware is visible during initialization via the
     #: CUDA_VISIBLE_DEVICES environment variable.
-    CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = ccuda.cudaError_enum.CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE{{endif}}
+    CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE = cydriver.cudaError_enum.CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE{{endif}}
     {{if 'CUDA_ERROR_MPS_CONNECTION_FAILED' in found_values}}
 
     #: This error indicates that the MPS client failed to connect to the
     #: MPS control daemon or the MPS server.
-    CUDA_ERROR_MPS_CONNECTION_FAILED = ccuda.cudaError_enum.CUDA_ERROR_MPS_CONNECTION_FAILED{{endif}}
+    CUDA_ERROR_MPS_CONNECTION_FAILED = cydriver.cudaError_enum.CUDA_ERROR_MPS_CONNECTION_FAILED{{endif}}
     {{if 'CUDA_ERROR_MPS_RPC_FAILURE' in found_values}}
 
     #: This error indicates that the remote procedural call between the MPS
     #: server and the MPS client failed.
-    CUDA_ERROR_MPS_RPC_FAILURE = ccuda.cudaError_enum.CUDA_ERROR_MPS_RPC_FAILURE{{endif}}
+    CUDA_ERROR_MPS_RPC_FAILURE = cydriver.cudaError_enum.CUDA_ERROR_MPS_RPC_FAILURE{{endif}}
     {{if 'CUDA_ERROR_MPS_SERVER_NOT_READY' in found_values}}
 
     #: This error indicates that the MPS server is not ready to accept new
     #: MPS client requests. This error can be returned when the MPS server
     #: is in the process of recovering from a fatal failure.
-    CUDA_ERROR_MPS_SERVER_NOT_READY = ccuda.cudaError_enum.CUDA_ERROR_MPS_SERVER_NOT_READY{{endif}}
+    CUDA_ERROR_MPS_SERVER_NOT_READY = cydriver.cudaError_enum.CUDA_ERROR_MPS_SERVER_NOT_READY{{endif}}
     {{if 'CUDA_ERROR_MPS_MAX_CLIENTS_REACHED' in found_values}}
 
     #: This error indicates that the hardware resources required to create
     #: MPS client have been exhausted.
-    CUDA_ERROR_MPS_MAX_CLIENTS_REACHED = ccuda.cudaError_enum.CUDA_ERROR_MPS_MAX_CLIENTS_REACHED{{endif}}
+    CUDA_ERROR_MPS_MAX_CLIENTS_REACHED = cydriver.cudaError_enum.CUDA_ERROR_MPS_MAX_CLIENTS_REACHED{{endif}}
     {{if 'CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED' in found_values}}
 
     #: This error indicates the the hardware resources required to support
     #: device connections have been exhausted.
-    CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED = ccuda.cudaError_enum.CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED{{endif}}
+    CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED = cydriver.cudaError_enum.CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED{{endif}}
     {{if 'CUDA_ERROR_MPS_CLIENT_TERMINATED' in found_values}}
 
     #: This error indicates that the MPS client has been terminated by the
     #: server. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    CUDA_ERROR_MPS_CLIENT_TERMINATED = ccuda.cudaError_enum.CUDA_ERROR_MPS_CLIENT_TERMINATED{{endif}}
+    CUDA_ERROR_MPS_CLIENT_TERMINATED = cydriver.cudaError_enum.CUDA_ERROR_MPS_CLIENT_TERMINATED{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED' in found_values}}
 
     #: This error indicates that the operation is not permitted when the
     #: stream is capturing.
-    CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_INVALIDATED' in found_values}}
 
     #: This error indicates that the current capture sequence on the stream
     #: has been invalidated due to a previous error.
-    CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_INVALIDATED{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_INVALIDATED = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_INVALIDATED{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_MERGE' in found_values}}
 
     #: This error indicates that the operation would have resulted in a
     #: merge of two independent capture sequences.
-    CUDA_ERROR_STREAM_CAPTURE_MERGE = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_MERGE{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_MERGE = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_MERGE{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_UNMATCHED' in found_values}}
 
     #: This error indicates that the capture was not initiated in this
     #: stream.
-    CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNMATCHED{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_UNMATCHED = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNMATCHED{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_UNJOINED' in found_values}}
 
     #: This error indicates that the capture sequence contains a fork that
     #: was not joined to the primary stream.
-    CUDA_ERROR_STREAM_CAPTURE_UNJOINED = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNJOINED{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_UNJOINED = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_UNJOINED{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_ISOLATION' in found_values}}
 
     #: This error indicates that a dependency would have been created which
     #: crosses the capture sequence boundary. Only implicit in-stream
     #: ordering dependencies are allowed to cross the boundary.
-    CUDA_ERROR_STREAM_CAPTURE_ISOLATION = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_ISOLATION{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_ISOLATION = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_ISOLATION{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_IMPLICIT' in found_values}}
 
     #: This error indicates a disallowed implicit dependency on a current
     #: capture sequence from cudaStreamLegacy.
-    CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_IMPLICIT{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_IMPLICIT = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_IMPLICIT{{endif}}
     {{if 'CUDA_ERROR_CAPTURED_EVENT' in found_values}}
 
     #: This error indicates that the operation is not permitted on an event
     #: which was last recorded in a capturing stream.
-    CUDA_ERROR_CAPTURED_EVENT = ccuda.cudaError_enum.CUDA_ERROR_CAPTURED_EVENT{{endif}}
+    CUDA_ERROR_CAPTURED_EVENT = cydriver.cudaError_enum.CUDA_ERROR_CAPTURED_EVENT{{endif}}
     {{if 'CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD' in found_values}}
 
     #: A stream capture sequence not initiated with the
     #: :py:obj:`~.CU_STREAM_CAPTURE_MODE_RELAXED` argument to
     #: :py:obj:`~.cuStreamBeginCapture` was passed to
     #: :py:obj:`~.cuStreamEndCapture` in a different thread.
-    CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = ccuda.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD{{endif}}
+    CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD = cydriver.cudaError_enum.CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD{{endif}}
     {{if 'CUDA_ERROR_TIMEOUT' in found_values}}
 
     #: This error indicates that the timeout specified for the wait
     #: operation has lapsed.
-    CUDA_ERROR_TIMEOUT = ccuda.cudaError_enum.CUDA_ERROR_TIMEOUT{{endif}}
+    CUDA_ERROR_TIMEOUT = cydriver.cudaError_enum.CUDA_ERROR_TIMEOUT{{endif}}
     {{if 'CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE' in found_values}}
 
     #: This error indicates that the graph update was not performed because
     #: it included changes which violated constraints specific to
     #: instantiated graph update.
-    CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = ccuda.cudaError_enum.CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE{{endif}}
+    CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE = cydriver.cudaError_enum.CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE{{endif}}
     {{if 'CUDA_ERROR_EXTERNAL_DEVICE' in found_values}}
 
     #: This indicates that an async error has occurred in a device outside
@@ -3226,15 +3107,15 @@ class CUresult(IntEnum):
     #: the process in an inconsistent state and any further CUDA work will
     #: return the same error. To continue using CUDA, the process must be
     #: terminated and relaunched.
-    CUDA_ERROR_EXTERNAL_DEVICE = ccuda.cudaError_enum.CUDA_ERROR_EXTERNAL_DEVICE{{endif}}
+    CUDA_ERROR_EXTERNAL_DEVICE = cydriver.cudaError_enum.CUDA_ERROR_EXTERNAL_DEVICE{{endif}}
     {{if 'CUDA_ERROR_INVALID_CLUSTER_SIZE' in found_values}}
 
     #: Indicates a kernel launch error due to cluster misconfiguration.
-    CUDA_ERROR_INVALID_CLUSTER_SIZE = ccuda.cudaError_enum.CUDA_ERROR_INVALID_CLUSTER_SIZE{{endif}}
+    CUDA_ERROR_INVALID_CLUSTER_SIZE = cydriver.cudaError_enum.CUDA_ERROR_INVALID_CLUSTER_SIZE{{endif}}
     {{if 'CUDA_ERROR_UNKNOWN' in found_values}}
 
     #: This indicates that an unknown internal error has occurred.
-    CUDA_ERROR_UNKNOWN = ccuda.cudaError_enum.CUDA_ERROR_UNKNOWN{{endif}}
+    CUDA_ERROR_UNKNOWN = cydriver.cudaError_enum.CUDA_ERROR_UNKNOWN{{endif}}
 {{endif}}
 {{if 'CUdevice_P2PAttribute_enum' in found_types}}
 
@@ -3246,23 +3127,23 @@ class CUdevice_P2PAttribute(IntEnum):
 
     #: A relative value indicating the performance of the link between two
     #: devices
-    CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = ccuda.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK{{endif}}
+    CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK{{endif}}
     {{if 'CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED' in found_values}}
 
     #: P2P Access is enable
-    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = ccuda.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED{{endif}}
+    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED' in found_values}}
 
     #: Atomic operation over the link supported
-    CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = ccuda.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED{{endif}}
+    CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED' in found_values}}
 
     #: [Deprecated]
-    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = ccuda.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED{{endif}}
+    CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED{{endif}}
     {{if 'CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED' in found_values}}
 
     #: Accessing CUDA arrays over the link supported
-    CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED = ccuda.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED{{endif}}
+    CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED = cydriver.CUdevice_P2PAttribute_enum.CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED{{endif}}
 {{endif}}
 {{if 'CUresourceViewFormat_enum' in found_types}}
 
@@ -3273,143 +3154,143 @@ class CUresourceViewFormat(IntEnum):
     {{if 'CU_RES_VIEW_FORMAT_NONE' in found_values}}
 
     #: No resource view format (use underlying resource format)
-    CU_RES_VIEW_FORMAT_NONE = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_NONE{{endif}}
+    CU_RES_VIEW_FORMAT_NONE = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_NONE{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_1X8' in found_values}}
 
     #: 1 channel unsigned 8-bit integers
-    CU_RES_VIEW_FORMAT_UINT_1X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X8{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_1X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_2X8' in found_values}}
 
     #: 2 channel unsigned 8-bit integers
-    CU_RES_VIEW_FORMAT_UINT_2X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X8{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_2X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_4X8' in found_values}}
 
     #: 4 channel unsigned 8-bit integers
-    CU_RES_VIEW_FORMAT_UINT_4X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X8{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_4X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_1X8' in found_values}}
 
     #: 1 channel signed 8-bit integers
-    CU_RES_VIEW_FORMAT_SINT_1X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X8{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_1X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_2X8' in found_values}}
 
     #: 2 channel signed 8-bit integers
-    CU_RES_VIEW_FORMAT_SINT_2X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X8{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_2X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_4X8' in found_values}}
 
     #: 4 channel signed 8-bit integers
-    CU_RES_VIEW_FORMAT_SINT_4X8 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X8{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_4X8 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X8{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_1X16' in found_values}}
 
     #: 1 channel unsigned 16-bit integers
-    CU_RES_VIEW_FORMAT_UINT_1X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X16{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_1X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_2X16' in found_values}}
 
     #: 2 channel unsigned 16-bit integers
-    CU_RES_VIEW_FORMAT_UINT_2X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X16{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_2X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_4X16' in found_values}}
 
     #: 4 channel unsigned 16-bit integers
-    CU_RES_VIEW_FORMAT_UINT_4X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X16{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_4X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_1X16' in found_values}}
 
     #: 1 channel signed 16-bit integers
-    CU_RES_VIEW_FORMAT_SINT_1X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X16{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_1X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_2X16' in found_values}}
 
     #: 2 channel signed 16-bit integers
-    CU_RES_VIEW_FORMAT_SINT_2X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X16{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_2X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_4X16' in found_values}}
 
     #: 4 channel signed 16-bit integers
-    CU_RES_VIEW_FORMAT_SINT_4X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X16{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_4X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_1X32' in found_values}}
 
     #: 1 channel unsigned 32-bit integers
-    CU_RES_VIEW_FORMAT_UINT_1X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X32{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_1X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_1X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_2X32' in found_values}}
 
     #: 2 channel unsigned 32-bit integers
-    CU_RES_VIEW_FORMAT_UINT_2X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X32{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_2X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_2X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UINT_4X32' in found_values}}
 
     #: 4 channel unsigned 32-bit integers
-    CU_RES_VIEW_FORMAT_UINT_4X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X32{{endif}}
+    CU_RES_VIEW_FORMAT_UINT_4X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UINT_4X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_1X32' in found_values}}
 
     #: 1 channel signed 32-bit integers
-    CU_RES_VIEW_FORMAT_SINT_1X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X32{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_1X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_1X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_2X32' in found_values}}
 
     #: 2 channel signed 32-bit integers
-    CU_RES_VIEW_FORMAT_SINT_2X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X32{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_2X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_2X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SINT_4X32' in found_values}}
 
     #: 4 channel signed 32-bit integers
-    CU_RES_VIEW_FORMAT_SINT_4X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X32{{endif}}
+    CU_RES_VIEW_FORMAT_SINT_4X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SINT_4X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_1X16' in found_values}}
 
     #: 1 channel 16-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_1X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_1X16{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_1X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_1X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_2X16' in found_values}}
 
     #: 2 channel 16-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_2X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_2X16{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_2X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_2X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_4X16' in found_values}}
 
     #: 4 channel 16-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_4X16 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_4X16{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_4X16 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_4X16{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_1X32' in found_values}}
 
     #: 1 channel 32-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_1X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_1X32{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_1X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_1X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_2X32' in found_values}}
 
     #: 2 channel 32-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_2X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_2X32{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_2X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_2X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_FLOAT_4X32' in found_values}}
 
     #: 4 channel 32-bit floating point
-    CU_RES_VIEW_FORMAT_FLOAT_4X32 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_4X32{{endif}}
+    CU_RES_VIEW_FORMAT_FLOAT_4X32 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_FLOAT_4X32{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC1' in found_values}}
 
     #: Block compressed 1
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC1{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC1 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC1{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC2' in found_values}}
 
     #: Block compressed 2
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC2{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC2 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC2{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC3' in found_values}}
 
     #: Block compressed 3
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC3{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC3 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC3{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC4' in found_values}}
 
     #: Block compressed 4 unsigned
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC4{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC4 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC4{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SIGNED_BC4' in found_values}}
 
     #: Block compressed 4 signed
-    CU_RES_VIEW_FORMAT_SIGNED_BC4 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC4{{endif}}
+    CU_RES_VIEW_FORMAT_SIGNED_BC4 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC4{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC5' in found_values}}
 
     #: Block compressed 5 unsigned
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC5{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC5 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC5{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SIGNED_BC5' in found_values}}
 
     #: Block compressed 5 signed
-    CU_RES_VIEW_FORMAT_SIGNED_BC5 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC5{{endif}}
+    CU_RES_VIEW_FORMAT_SIGNED_BC5 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC5{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC6H' in found_values}}
 
     #: Block compressed 6 unsigned half-float
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC6H{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC6H = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC6H{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_SIGNED_BC6H' in found_values}}
 
     #: Block compressed 6 signed half-float
-    CU_RES_VIEW_FORMAT_SIGNED_BC6H = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC6H{{endif}}
+    CU_RES_VIEW_FORMAT_SIGNED_BC6H = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_SIGNED_BC6H{{endif}}
     {{if 'CU_RES_VIEW_FORMAT_UNSIGNED_BC7' in found_values}}
 
     #: Block compressed 7
-    CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = ccuda.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC7{{endif}}
+    CU_RES_VIEW_FORMAT_UNSIGNED_BC7 = cydriver.CUresourceViewFormat_enum.CU_RES_VIEW_FORMAT_UNSIGNED_BC7{{endif}}
 {{endif}}
 {{if 'CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum' in found_types}}
 
@@ -3423,17 +3304,17 @@ class CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS(IntEnum):
     #: No access, meaning the device cannot access this memory at all, thus
     #: must be staged through accessible memory in order to complete
     #: certain operations
-    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE = ccuda.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE{{endif}}
+    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE = cydriver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ' in found_values}}
 
     #: Read-only access, meaning writes to this memory are considered
     #: invalid accesses and thus return error in that case.
-    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ = ccuda.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ{{endif}}
+    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ = cydriver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ{{endif}}
     {{if 'CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE' in found_values}}
 
     #: Read-write access, the device has full read-write access to the
     #: memory
-    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE = ccuda.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE{{endif}}
+    CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE = cydriver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS_enum.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE{{endif}}
 {{endif}}
 {{if 'CUexternalMemoryHandleType_enum' in found_types}}
 
@@ -3444,35 +3325,35 @@ class CUexternalMemoryHandleType(IntEnum):
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD' in found_values}}
 
     #: Handle is an opaque file descriptor
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32' in found_values}}
 
     #: Handle is an opaque shared NT handle
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32 = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT' in found_values}}
 
     #: Handle is an opaque, globally shared handle
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP' in found_values}}
 
     #: Handle is a D3D12 heap object
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE' in found_values}}
 
     #: Handle is a D3D12 committed resource
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE' in found_values}}
 
     #: Handle is a shared NT handle to a D3D11 resource
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT' in found_values}}
 
     #: Handle is a globally shared handle to a D3D11 resource
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT{{endif}}
     {{if 'CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF' in found_values}}
 
     #: Handle is an NvSciBuf object
-    CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = ccuda.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF{{endif}}
+    CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF = cydriver.CUexternalMemoryHandleType_enum.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF{{endif}}
 {{endif}}
 {{if 'CUexternalSemaphoreHandleType_enum' in found_types}}
 
@@ -3483,45 +3364,45 @@ class CUexternalSemaphoreHandleType(IntEnum):
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD' in found_values}}
 
     #: Handle is an opaque file descriptor
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32' in found_values}}
 
     #: Handle is an opaque shared NT handle
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32 = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT' in found_values}}
 
     #: Handle is an opaque, globally shared handle
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE' in found_values}}
 
     #: Handle is a shared NT handle referencing a D3D12 fence object
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE' in found_values}}
 
     #: Handle is a shared NT handle referencing a D3D11 fence object
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC' in found_values}}
 
     #: Opaque handle to NvSciSync Object
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX' in found_values}}
 
     #: Handle is a shared NT handle referencing a D3D11 keyed mutex object
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT' in found_values}}
 
     #: Handle is a globally shared handle referencing a D3D11 keyed mutex
     #: object
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD' in found_values}}
 
     #: Handle is an opaque file descriptor referencing a timeline semaphore
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD{{endif}}
     {{if 'CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32' in found_values}}
 
     #: Handle is an opaque shared NT handle referencing a timeline
     #: semaphore
-    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = ccuda.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32{{endif}}
+    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32 = cydriver.CUexternalSemaphoreHandleType_enum.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32{{endif}}
 {{endif}}
 {{if 'CUmemAllocationHandleType_enum' in found_types}}
 
@@ -3532,22 +3413,22 @@ class CUmemAllocationHandleType(IntEnum):
     {{if 'CU_MEM_HANDLE_TYPE_NONE' in found_values}}
 
     #: Does not allow any export mechanism. >
-    CU_MEM_HANDLE_TYPE_NONE = ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE{{endif}}
+    CU_MEM_HANDLE_TYPE_NONE = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_NONE{{endif}}
     {{if 'CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR' in found_values}}
 
     #: Allows a file descriptor to be used for exporting. Permitted only on
     #: POSIX systems. (int)
-    CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR{{endif}}
+    CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR{{endif}}
     {{if 'CU_MEM_HANDLE_TYPE_WIN32' in found_values}}
 
     #: Allows a Win32 NT handle to be used for exporting. (HANDLE)
-    CU_MEM_HANDLE_TYPE_WIN32 = ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32{{endif}}
+    CU_MEM_HANDLE_TYPE_WIN32 = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32{{endif}}
     {{if 'CU_MEM_HANDLE_TYPE_WIN32_KMT' in found_values}}
 
     #: Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)
-    CU_MEM_HANDLE_TYPE_WIN32_KMT = ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT{{endif}}
+    CU_MEM_HANDLE_TYPE_WIN32_KMT = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_WIN32_KMT{{endif}}
     {{if 'CU_MEM_HANDLE_TYPE_MAX' in found_values}}
-    CU_MEM_HANDLE_TYPE_MAX = ccuda.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_MAX{{endif}}
+    CU_MEM_HANDLE_TYPE_MAX = cydriver.CUmemAllocationHandleType_enum.CU_MEM_HANDLE_TYPE_MAX{{endif}}
 {{endif}}
 {{if 'CUmemAccess_flags_enum' in found_types}}
 
@@ -3558,17 +3439,17 @@ class CUmemAccess_flags(IntEnum):
     {{if 'CU_MEM_ACCESS_FLAGS_PROT_NONE' in found_values}}
 
     #: Default, make the address range not accessible
-    CU_MEM_ACCESS_FLAGS_PROT_NONE = ccuda.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_NONE{{endif}}
+    CU_MEM_ACCESS_FLAGS_PROT_NONE = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_NONE{{endif}}
     {{if 'CU_MEM_ACCESS_FLAGS_PROT_READ' in found_values}}
 
     #: Make the address range read accessible
-    CU_MEM_ACCESS_FLAGS_PROT_READ = ccuda.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_READ{{endif}}
+    CU_MEM_ACCESS_FLAGS_PROT_READ = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_READ{{endif}}
     {{if 'CU_MEM_ACCESS_FLAGS_PROT_READWRITE' in found_values}}
 
     #: Make the address range read-write accessible
-    CU_MEM_ACCESS_FLAGS_PROT_READWRITE = ccuda.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_READWRITE{{endif}}
+    CU_MEM_ACCESS_FLAGS_PROT_READWRITE = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_READWRITE{{endif}}
     {{if 'CU_MEM_ACCESS_FLAGS_PROT_MAX' in found_values}}
-    CU_MEM_ACCESS_FLAGS_PROT_MAX = ccuda.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_MAX{{endif}}
+    CU_MEM_ACCESS_FLAGS_PROT_MAX = cydriver.CUmemAccess_flags_enum.CU_MEM_ACCESS_FLAGS_PROT_MAX{{endif}}
 {{endif}}
 {{if 'CUmemLocationType_enum' in found_types}}
 
@@ -3577,13 +3458,13 @@ class CUmemLocationType(IntEnum):
     Specifies the type of location
     """
     {{if 'CU_MEM_LOCATION_TYPE_INVALID' in found_values}}
-    CU_MEM_LOCATION_TYPE_INVALID = ccuda.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_INVALID{{endif}}
+    CU_MEM_LOCATION_TYPE_INVALID = cydriver.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_INVALID{{endif}}
     {{if 'CU_MEM_LOCATION_TYPE_DEVICE' in found_values}}
 
     #: Location is a device location, thus id is a device ordinal
-    CU_MEM_LOCATION_TYPE_DEVICE = ccuda.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_DEVICE{{endif}}
+    CU_MEM_LOCATION_TYPE_DEVICE = cydriver.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_DEVICE{{endif}}
     {{if 'CU_MEM_LOCATION_TYPE_MAX' in found_values}}
-    CU_MEM_LOCATION_TYPE_MAX = ccuda.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_MAX{{endif}}
+    CU_MEM_LOCATION_TYPE_MAX = cydriver.CUmemLocationType_enum.CU_MEM_LOCATION_TYPE_MAX{{endif}}
 {{endif}}
 {{if 'CUmemAllocationType_enum' in found_types}}
 
@@ -3592,14 +3473,14 @@ class CUmemAllocationType(IntEnum):
     Defines the allocation types available
     """
     {{if 'CU_MEM_ALLOCATION_TYPE_INVALID' in found_values}}
-    CU_MEM_ALLOCATION_TYPE_INVALID = ccuda.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_INVALID{{endif}}
+    CU_MEM_ALLOCATION_TYPE_INVALID = cydriver.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_INVALID{{endif}}
     {{if 'CU_MEM_ALLOCATION_TYPE_PINNED' in found_values}}
 
     #: This allocation type is 'pinned', i.e. cannot migrate from its
     #: current location while the application is actively using it
-    CU_MEM_ALLOCATION_TYPE_PINNED = ccuda.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_PINNED{{endif}}
+    CU_MEM_ALLOCATION_TYPE_PINNED = cydriver.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_PINNED{{endif}}
     {{if 'CU_MEM_ALLOCATION_TYPE_MAX' in found_values}}
-    CU_MEM_ALLOCATION_TYPE_MAX = ccuda.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_MAX{{endif}}
+    CU_MEM_ALLOCATION_TYPE_MAX = cydriver.CUmemAllocationType_enum.CU_MEM_ALLOCATION_TYPE_MAX{{endif}}
 {{endif}}
 {{if 'CUmemAllocationGranularity_flags_enum' in found_types}}
 
@@ -3611,11 +3492,11 @@ class CUmemAllocationGranularity_flags(IntEnum):
     {{if 'CU_MEM_ALLOC_GRANULARITY_MINIMUM' in found_values}}
 
     #: Minimum required granularity for allocation
-    CU_MEM_ALLOC_GRANULARITY_MINIMUM = ccuda.CUmemAllocationGranularity_flags_enum.CU_MEM_ALLOC_GRANULARITY_MINIMUM{{endif}}
+    CU_MEM_ALLOC_GRANULARITY_MINIMUM = cydriver.CUmemAllocationGranularity_flags_enum.CU_MEM_ALLOC_GRANULARITY_MINIMUM{{endif}}
     {{if 'CU_MEM_ALLOC_GRANULARITY_RECOMMENDED' in found_values}}
 
     #: Recommended granularity for allocation for best performance
-    CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = ccuda.CUmemAllocationGranularity_flags_enum.CU_MEM_ALLOC_GRANULARITY_RECOMMENDED{{endif}}
+    CU_MEM_ALLOC_GRANULARITY_RECOMMENDED = cydriver.CUmemAllocationGranularity_flags_enum.CU_MEM_ALLOC_GRANULARITY_RECOMMENDED{{endif}}
 {{endif}}
 {{if 'CUmemRangeHandleType_enum' in found_types}}
 
@@ -3624,9 +3505,9 @@ class CUmemRangeHandleType(IntEnum):
     Specifies the handle type for address range
     """
     {{if 'CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD' in found_values}}
-    CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD = ccuda.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD{{endif}}
+    CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD = cydriver.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD{{endif}}
     {{if 'CU_MEM_RANGE_HANDLE_TYPE_MAX' in found_values}}
-    CU_MEM_RANGE_HANDLE_TYPE_MAX = ccuda.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_MAX{{endif}}
+    CU_MEM_RANGE_HANDLE_TYPE_MAX = cydriver.CUmemRangeHandleType_enum.CU_MEM_RANGE_HANDLE_TYPE_MAX{{endif}}
 {{endif}}
 {{if 'CUarraySparseSubresourceType_enum' in found_types}}
 
@@ -3635,9 +3516,9 @@ class CUarraySparseSubresourceType(IntEnum):
     Sparse subresource types
     """
     {{if 'CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL' in found_values}}
-    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = ccuda.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL{{endif}}
+    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL = cydriver.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL{{endif}}
     {{if 'CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL' in found_values}}
-    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = ccuda.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL{{endif}}
+    CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL = cydriver.CUarraySparseSubresourceType_enum.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL{{endif}}
 {{endif}}
 {{if 'CUmemOperationType_enum' in found_types}}
 
@@ -3646,9 +3527,9 @@ class CUmemOperationType(IntEnum):
     Memory operation types
     """
     {{if 'CU_MEM_OPERATION_TYPE_MAP' in found_values}}
-    CU_MEM_OPERATION_TYPE_MAP = ccuda.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_MAP{{endif}}
+    CU_MEM_OPERATION_TYPE_MAP = cydriver.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_MAP{{endif}}
     {{if 'CU_MEM_OPERATION_TYPE_UNMAP' in found_values}}
-    CU_MEM_OPERATION_TYPE_UNMAP = ccuda.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_UNMAP{{endif}}
+    CU_MEM_OPERATION_TYPE_UNMAP = cydriver.CUmemOperationType_enum.CU_MEM_OPERATION_TYPE_UNMAP{{endif}}
 {{endif}}
 {{if 'CUmemHandleType_enum' in found_types}}
 
@@ -3657,7 +3538,7 @@ class CUmemHandleType(IntEnum):
     Memory handle types
     """
     {{if 'CU_MEM_HANDLE_TYPE_GENERIC' in found_values}}
-    CU_MEM_HANDLE_TYPE_GENERIC = ccuda.CUmemHandleType_enum.CU_MEM_HANDLE_TYPE_GENERIC{{endif}}
+    CU_MEM_HANDLE_TYPE_GENERIC = cydriver.CUmemHandleType_enum.CU_MEM_HANDLE_TYPE_GENERIC{{endif}}
 {{endif}}
 {{if 'CUmemAllocationCompType_enum' in found_types}}
 
@@ -3668,11 +3549,11 @@ class CUmemAllocationCompType(IntEnum):
     {{if 'CU_MEM_ALLOCATION_COMP_NONE' in found_values}}
 
     #: Allocating non-compressible memory
-    CU_MEM_ALLOCATION_COMP_NONE = ccuda.CUmemAllocationCompType_enum.CU_MEM_ALLOCATION_COMP_NONE{{endif}}
+    CU_MEM_ALLOCATION_COMP_NONE = cydriver.CUmemAllocationCompType_enum.CU_MEM_ALLOCATION_COMP_NONE{{endif}}
     {{if 'CU_MEM_ALLOCATION_COMP_GENERIC' in found_values}}
 
     #: Allocating compressible memory
-    CU_MEM_ALLOCATION_COMP_GENERIC = ccuda.CUmemAllocationCompType_enum.CU_MEM_ALLOCATION_COMP_GENERIC{{endif}}
+    CU_MEM_ALLOCATION_COMP_GENERIC = cydriver.CUmemAllocationCompType_enum.CU_MEM_ALLOCATION_COMP_GENERIC{{endif}}
 {{endif}}
 {{if 'CUgraphExecUpdateResult_enum' in found_types}}
 
@@ -3683,44 +3564,44 @@ class CUgraphExecUpdateResult(IntEnum):
     {{if 'CU_GRAPH_EXEC_UPDATE_SUCCESS' in found_values}}
 
     #: The update succeeded
-    CU_GRAPH_EXEC_UPDATE_SUCCESS = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_SUCCESS{{endif}}
+    CU_GRAPH_EXEC_UPDATE_SUCCESS = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_SUCCESS{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR' in found_values}}
 
     #: The update failed for an unexpected reason which is described in the
     #: return value of the function
-    CU_GRAPH_EXEC_UPDATE_ERROR = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED' in found_values}}
 
     #: The update failed because the topology changed
-    CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED' in found_values}}
 
     #: The update failed because a node type changed
-    CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED' in found_values}}
 
     #: The update failed because the function of a kernel node changed
     #: (CUDA driver < 11.2)
-    CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED' in found_values}}
 
     #: The update failed because the parameters changed in a way that is
     #: not supported
-    CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED' in found_values}}
 
     #: The update failed because something about the node is not supported
-    CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE' in found_values}}
 
     #: The update failed because the function of a kernel node changed in
     #: an unsupported way
-    CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE{{endif}}
     {{if 'CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED' in found_values}}
 
     #: The update failed because the node attributes changed in a way that
     #: is not supported
-    CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED = ccuda.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED{{endif}}
+    CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED = cydriver.CUgraphExecUpdateResult_enum.CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED{{endif}}
 {{endif}}
 {{if 'CUmemPool_attribute_enum' in found_types}}
 
@@ -3735,18 +3616,18 @@ class CUmemPool_attribute(IntEnum):
     #: dependency of the allocating stream on the free action exists. Cuda
     #: events and null stream interactions can create the required stream
     #: ordered dependencies. (default enabled)
-    CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES{{endif}}
+    CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES{{endif}}
     {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC' in found_values}}
 
     #: (value type = int) Allow reuse of already completed frees when there
     #: is no dependency between the free and allocation. (default enabled)
-    CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC{{endif}}
+    CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC{{endif}}
     {{if 'CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES' in found_values}}
 
     #: (value type = int) Allow cuMemAllocAsync to insert new stream
     #: dependencies in order to establish the stream ordering required to
     #: reuse a piece of memory released by cuFreeAsync (default enabled).
-    CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES{{endif}}
+    CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES{{endif}}
     {{if 'CU_MEMPOOL_ATTR_RELEASE_THRESHOLD' in found_values}}
 
     #: (value type = cuuint64_t) Amount of reserved memory in bytes to hold
@@ -3754,29 +3635,29 @@ class CUmemPool_attribute(IntEnum):
     #: the release threshold bytes of memory are held by the memory pool,
     #: the allocator will try to release memory back to the OS on the next
     #: call to stream, event or context synchronize. (default 0)
-    CU_MEMPOOL_ATTR_RELEASE_THRESHOLD = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD{{endif}}
+    CU_MEMPOOL_ATTR_RELEASE_THRESHOLD = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD{{endif}}
     {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT' in found_values}}
 
     #: (value type = cuuint64_t) Amount of backing memory currently
     #: allocated for the mempool.
-    CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT{{endif}}
+    CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT{{endif}}
     {{if 'CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH' in found_values}}
 
     #: (value type = cuuint64_t) High watermark of backing memory allocated
     #: for the mempool since the last time it was reset. High watermark can
     #: only be reset to zero.
-    CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH{{endif}}
+    CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH{{endif}}
     {{if 'CU_MEMPOOL_ATTR_USED_MEM_CURRENT' in found_values}}
 
     #: (value type = cuuint64_t) Amount of memory from the pool that is
     #: currently in use by the application.
-    CU_MEMPOOL_ATTR_USED_MEM_CURRENT = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT{{endif}}
+    CU_MEMPOOL_ATTR_USED_MEM_CURRENT = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_CURRENT{{endif}}
     {{if 'CU_MEMPOOL_ATTR_USED_MEM_HIGH' in found_values}}
 
     #: (value type = cuuint64_t) High watermark of the amount of memory
     #: from the pool that was in use by the application since the last time
     #: it was reset. High watermark can only be reset to zero.
-    CU_MEMPOOL_ATTR_USED_MEM_HIGH = ccuda.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH{{endif}}
+    CU_MEMPOOL_ATTR_USED_MEM_HIGH = cydriver.CUmemPool_attribute_enum.CU_MEMPOOL_ATTR_USED_MEM_HIGH{{endif}}
 {{endif}}
 {{if 'CUgraphMem_attribute_enum' in found_types}}
 
@@ -3788,24 +3669,24 @@ class CUgraphMem_attribute(IntEnum):
 
     #: (value type = cuuint64_t) Amount of memory, in bytes, currently
     #: associated with graphs
-    CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT = ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT{{endif}}
+    CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT{{endif}}
     {{if 'CU_GRAPH_MEM_ATTR_USED_MEM_HIGH' in found_values}}
 
     #: (value type = cuuint64_t) High watermark of memory, in bytes,
     #: associated with graphs since the last time it was reset. High
     #: watermark can only be reset to zero.
-    CU_GRAPH_MEM_ATTR_USED_MEM_HIGH = ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH{{endif}}
+    CU_GRAPH_MEM_ATTR_USED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH{{endif}}
     {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT' in found_values}}
 
     #: (value type = cuuint64_t) Amount of memory, in bytes, currently
     #: allocated for use by the CUDA graphs asynchronous allocator.
-    CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT = ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT{{endif}}
+    CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT{{endif}}
     {{if 'CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH' in found_values}}
 
     #: (value type = cuuint64_t) High watermark of memory, in bytes,
     #: currently allocated for use by the CUDA graphs asynchronous
     #: allocator.
-    CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH = ccuda.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH{{endif}}
+    CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH = cydriver.CUgraphMem_attribute_enum.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH{{endif}}
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesOptions_enum' in found_types}}
 
@@ -3818,13 +3699,13 @@ class CUflushGPUDirectRDMAWritesOptions(IntEnum):
 
     #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` and its CUDA Runtime API
     #: counterpart are supported on the device.
-    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = ccuda.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST{{endif}}
+    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST{{endif}}
     {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS' in found_values}}
 
     #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the
     #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
     #: on the device.
-    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = ccuda.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS{{endif}}
+    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS = cydriver.CUflushGPUDirectRDMAWritesOptions_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS{{endif}}
 {{endif}}
 {{if 'CUGPUDirectRDMAWritesOrdering_enum' in found_types}}
 
@@ -3837,17 +3718,17 @@ class CUGPUDirectRDMAWritesOrdering(IntEnum):
     #: The device does not natively support ordering of remote writes.
     #: :py:obj:`~.cuFlushGPUDirectRDMAWrites()` can be leveraged if
     #: supported.
-    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = ccuda.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE{{endif}}
+    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE{{endif}}
     {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER' in found_values}}
 
     #: Natively, the device can consistently consume remote writes,
     #: although other CUDA devices may not.
-    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = ccuda.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER{{endif}}
+    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER{{endif}}
     {{if 'CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES' in found_values}}
 
     #: Any CUDA device in the system can consistently consume remote writes
     #: to this device.
-    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = ccuda.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES{{endif}}
+    CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES = cydriver.CUGPUDirectRDMAWritesOrdering_enum.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES{{endif}}
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesScope_enum' in found_types}}
 
@@ -3859,11 +3740,11 @@ class CUflushGPUDirectRDMAWritesScope(IntEnum):
 
     #: Blocks until remote writes are visible to the CUDA device context
     #: owning the data.
-    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = ccuda.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER{{endif}}
+    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER{{endif}}
     {{if 'CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES' in found_values}}
 
     #: Blocks until remote writes are visible to all CUDA device contexts.
-    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = ccuda.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES{{endif}}
+    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES = cydriver.CUflushGPUDirectRDMAWritesScope_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES{{endif}}
 {{endif}}
 {{if 'CUflushGPUDirectRDMAWritesTarget_enum' in found_types}}
 
@@ -3875,7 +3756,7 @@ class CUflushGPUDirectRDMAWritesTarget(IntEnum):
 
     #: Sets the target for :py:obj:`~.cuFlushGPUDirectRDMAWrites()` to the
     #: currently active CUDA device context.
-    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = ccuda.CUflushGPUDirectRDMAWritesTarget_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX{{endif}}
+    CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX = cydriver.CUflushGPUDirectRDMAWritesTarget_enum.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX{{endif}}
 {{endif}}
 {{if 'CUgraphDebugDot_flags_enum' in found_types}}
 
@@ -3884,57 +3765,57 @@ class CUgraphDebugDot_flags(IntEnum):
     The additional write options for :py:obj:`~.cuGraphDebugDotPrint`
     """
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE' in found_values}}
-    CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES' in found_values}}
 
     #: Output all debug data as if every debug flag is enabled
-    CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS' in found_values}}
 
     #: Use CUDA Runtime structures for output
-    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS' in found_values}}
 
     #: Adds CUDA_KERNEL_NODE_PARAMS values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS' in found_values}}
 
     #: Adds CUDA_MEMCPY3D values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS' in found_values}}
 
     #: Adds CUDA_MEMSET_NODE_PARAMS values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS' in found_values}}
 
     #: Adds CUDA_HOST_NODE_PARAMS values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS' in found_values}}
 
     #: Adds CUevent handle from record and wait nodes to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS' in found_values}}
 
     #: Adds CUDA_EXT_SEM_SIGNAL_NODE_PARAMS values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES' in found_values}}
 
     #: Adds CUDA_EXT_SEM_WAIT_NODE_PARAMS values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES' in found_values}}
 
     #: Adds CUkernelNodeAttrValue values to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS' in found_values}}
 
     #: Adds node handles and every kernel function handle to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS' in found_values}}
 
     #: Adds memory alloc node parameters to output
-    CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS{{endif}}
     {{if 'CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS' in found_values}}
-    CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS = ccuda.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS{{endif}}
+    CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS = cydriver.CUgraphDebugDot_flags_enum.CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS{{endif}}
 {{endif}}
 {{if 'CUuserObject_flags_enum' in found_types}}
 
@@ -3946,7 +3827,7 @@ class CUuserObject_flags(IntEnum):
 
     #: Indicates the destructor execution is not synchronized by any CUDA
     #: handle.
-    CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = ccuda.CUuserObject_flags_enum.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC{{endif}}
+    CU_USER_OBJECT_NO_DESTRUCTOR_SYNC = cydriver.CUuserObject_flags_enum.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC{{endif}}
 {{endif}}
 {{if 'CUuserObjectRetain_flags_enum' in found_types}}
 
@@ -3958,7 +3839,7 @@ class CUuserObjectRetain_flags(IntEnum):
 
     #: Transfer references from the caller rather than creating new
     #: references.
-    CU_GRAPH_USER_OBJECT_MOVE = ccuda.CUuserObjectRetain_flags_enum.CU_GRAPH_USER_OBJECT_MOVE{{endif}}
+    CU_GRAPH_USER_OBJECT_MOVE = cydriver.CUuserObjectRetain_flags_enum.CU_GRAPH_USER_OBJECT_MOVE{{endif}}
 {{endif}}
 {{if 'CUgraphInstantiate_flags_enum' in found_types}}
 
@@ -3969,12 +3850,12 @@ class CUgraphInstantiate_flags(IntEnum):
     {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH' in found_values}}
 
     #: Automatically free memory allocated in a graph before relaunching.
-    CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = ccuda.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH{{endif}}
+    CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH{{endif}}
     {{if 'CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY' in found_values}}
 
     #: Run the graph using the per-node priority attributes rather than the
     #: priority of the stream it is launched into.
-    CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = ccuda.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY{{endif}}
+    CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY = cydriver.CUgraphInstantiate_flags_enum.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY{{endif}}
 {{endif}}
 {{if 'CUmoduleLoadingMode_enum' in found_types}}
 
@@ -3985,11 +3866,11 @@ class CUmoduleLoadingMode(IntEnum):
     {{if 'CU_MODULE_EAGER_LOADING' in found_values}}
 
     #: Lazy Kernel Loading is not enabled
-    CU_MODULE_EAGER_LOADING = ccuda.CUmoduleLoadingMode_enum.CU_MODULE_EAGER_LOADING{{endif}}
+    CU_MODULE_EAGER_LOADING = cydriver.CUmoduleLoadingMode_enum.CU_MODULE_EAGER_LOADING{{endif}}
     {{if 'CU_MODULE_LAZY_LOADING' in found_values}}
 
     #: Lazy Kernel Loading is enabled
-    CU_MODULE_LAZY_LOADING = ccuda.CUmoduleLoadingMode_enum.CU_MODULE_LAZY_LOADING{{endif}}
+    CU_MODULE_LAZY_LOADING = cydriver.CUmoduleLoadingMode_enum.CU_MODULE_LAZY_LOADING{{endif}}
 {{endif}}
 {{if 'CUoutput_mode_enum' in found_types}}
 
@@ -4000,28 +3881,28 @@ class CUoutput_mode(IntEnum):
     {{if 'CU_OUT_KEY_VALUE_PAIR' in found_values}}
 
     #: Output mode Key-Value pair format.
-    CU_OUT_KEY_VALUE_PAIR = ccuda.CUoutput_mode_enum.CU_OUT_KEY_VALUE_PAIR{{endif}}
+    CU_OUT_KEY_VALUE_PAIR = cydriver.CUoutput_mode_enum.CU_OUT_KEY_VALUE_PAIR{{endif}}
     {{if 'CU_OUT_CSV' in found_values}}
 
     #: Output mode Comma separated values format.
-    CU_OUT_CSV = ccuda.CUoutput_mode_enum.CU_OUT_CSV{{endif}}
+    CU_OUT_CSV = cydriver.CUoutput_mode_enum.CU_OUT_CSV{{endif}}
 {{endif}}
-{{if True or 'CUeglFrameType_enum' in found_types}}
+{{if True}}
 
 class CUeglFrameType(IntEnum):
     """
     CUDA EglFrame type - array or pointer
     """
-    {{if True or 'CU_EGL_FRAME_TYPE_ARRAY' in found_values}}
+    {{if True}}
 
     #: Frame type CUDA array
-    CU_EGL_FRAME_TYPE_ARRAY = ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY{{endif}}
-    {{if True or 'CU_EGL_FRAME_TYPE_PITCH' in found_values}}
+    CU_EGL_FRAME_TYPE_ARRAY = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_ARRAY{{endif}}
+    {{if True}}
 
     #: Frame type pointer
-    CU_EGL_FRAME_TYPE_PITCH = ccuda.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH{{endif}}
+    CU_EGL_FRAME_TYPE_PITCH = cydriver.CUeglFrameType_enum.CU_EGL_FRAME_TYPE_PITCH{{endif}}
 {{endif}}
-{{if True or 'CUeglResourceLocationFlags_enum' in found_types}}
+{{if True}}
 
 class CUeglResourceLocationFlags(IntEnum):
     """
@@ -4037,16 +3918,16 @@ class CUeglResourceLocationFlags(IntEnum):
     by CUDA.  There may be an additional latency due to new allocation
     and data migration, if the frame is produced on a different memory.
     """
-    {{if True or 'CU_EGL_RESOURCE_LOCATION_SYSMEM' in found_values}}
+    {{if True}}
 
     #: Resource location sysmem
-    CU_EGL_RESOURCE_LOCATION_SYSMEM = ccuda.CUeglResourceLocationFlags_enum.CU_EGL_RESOURCE_LOCATION_SYSMEM{{endif}}
-    {{if True or 'CU_EGL_RESOURCE_LOCATION_VIDMEM' in found_values}}
+    CU_EGL_RESOURCE_LOCATION_SYSMEM = cydriver.CUeglResourceLocationFlags_enum.CU_EGL_RESOURCE_LOCATION_SYSMEM{{endif}}
+    {{if True}}
 
     #: Resource location vidmem
-    CU_EGL_RESOURCE_LOCATION_VIDMEM = ccuda.CUeglResourceLocationFlags_enum.CU_EGL_RESOURCE_LOCATION_VIDMEM{{endif}}
+    CU_EGL_RESOURCE_LOCATION_VIDMEM = cydriver.CUeglResourceLocationFlags_enum.CU_EGL_RESOURCE_LOCATION_VIDMEM{{endif}}
 {{endif}}
-{{if True or 'CUeglColorFormat_enum' in found_types}}
+{{if True}}
 
 class CUeglColorFormat(IntEnum):
     """
@@ -4055,602 +3936,602 @@ class CUeglColorFormat(IntEnum):
     formats are currently not supported for
     :py:obj:`~.CU_EGL_FRAME_TYPE_ARRAY`
     """
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_PLANAR' in found_values}}
+    {{if True}}
 
     #: Y, U, V in three surfaces, each in a separate surface, U/V width =
     #: 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR{{endif}}
+    {{if True}}
 
     #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
     #: width, height ratio same as YUV420Planar.
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV422_PLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V
     #: height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV422_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV422_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR{{endif}}
+    {{if True}}
 
     #: Y, UV in two surfaces with VU byte ordering, width, height ratio
     #: same as YUV422Planar.
-    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_RGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: R/G/B three channels in one surface with BGR byte ordering. Only
     #: pitch linear format supported.
-    CU_EGL_COLOR_FORMAT_RGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_RGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGB{{endif}}
+    {{if True}}
 
     #: R/G/B three channels in one surface with RGB byte ordering. Only
     #: pitch linear format supported.
-    CU_EGL_COLOR_FORMAT_BGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_ARGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGR{{endif}}
+    {{if True}}
 
     #: R/G/B/A four channels in one surface with BGRA byte ordering.
-    CU_EGL_COLOR_FORMAT_ARGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_RGBA' in found_values}}
+    CU_EGL_COLOR_FORMAT_ARGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ARGB{{endif}}
+    {{if True}}
 
     #: R/G/B/A four channels in one surface with ABGR byte ordering.
-    CU_EGL_COLOR_FORMAT_RGBA = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_L' in found_values}}
+    CU_EGL_COLOR_FORMAT_RGBA = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RGBA{{endif}}
+    {{if True}}
 
     #: single luminance channel in one surface.
-    CU_EGL_COLOR_FORMAT_L = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_R' in found_values}}
+    CU_EGL_COLOR_FORMAT_L = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_L{{endif}}
+    {{if True}}
 
     #: single color channel in one surface.
-    CU_EGL_COLOR_FORMAT_R = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV444_PLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_R = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_R{{endif}}
+    {{if True}}
 
     #: Y, U, V in three surfaces, each in a separate surface, U/V width = Y
     #: width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV444_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV444_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR{{endif}}
+    {{if True}}
 
     #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
     #: width, height ratio same as YUV444Planar.
-    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUYV_422' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y, U, V in one surface, interleaved as UYVY in one channel.
-    CU_EGL_COLOR_FORMAT_YUYV_422 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_UYVY_422' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUYV_422 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_422{{endif}}
+    {{if True}}
 
     #: Y, U, V in one surface, interleaved as YUYV in one channel.
-    CU_EGL_COLOR_FORMAT_UYVY_422 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_ABGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_UYVY_422 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_422{{endif}}
+    {{if True}}
 
     #: R/G/B/A four channels in one surface with RGBA byte ordering.
-    CU_EGL_COLOR_FORMAT_ABGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BGRA' in found_values}}
+    CU_EGL_COLOR_FORMAT_ABGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_ABGR{{endif}}
+    {{if True}}
 
     #: R/G/B/A four channels in one surface with ARGB byte ordering.
-    CU_EGL_COLOR_FORMAT_BGRA = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_A' in found_values}}
+    CU_EGL_COLOR_FORMAT_BGRA = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BGRA{{endif}}
+    {{if True}}
 
     #: Alpha color format - one channel in one surface.
-    CU_EGL_COLOR_FORMAT_A = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_RG' in found_values}}
+    CU_EGL_COLOR_FORMAT_A = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_A{{endif}}
+    {{if True}}
 
     #: R/G color format - two channels in one surface with GR byte ordering
-    CU_EGL_COLOR_FORMAT_RG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_AYUV' in found_values}}
+    CU_EGL_COLOR_FORMAT_RG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_RG{{endif}}
+    {{if True}}
 
     #: Y, U, V, A four channels in one surface, interleaved as VUYA.
-    CU_EGL_COLOR_FORMAT_AYUV = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_AYUV = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV{{endif}}
+    {{if True}}
 
     #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
     #: width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
     #: width = 1/2 Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
     #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
     #: ordering, U/V width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
     #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
     #: ordering, U/V width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
     #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_VYUY_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in one surface, interleaved as YVYU in one
     #: channel.
-    CU_EGL_COLOR_FORMAT_VYUY_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_UYVY_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_VYUY_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in one surface, interleaved as YUYV in one
     #: channel.
-    CU_EGL_COLOR_FORMAT_UYVY_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUYV_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_UYVY_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_UYVY_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in one surface, interleaved as UYVY in one
     #: channel.
-    CU_EGL_COLOR_FORMAT_YUYV_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVYU_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUYV_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUYV_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in one surface, interleaved as VYUY in one
     #: channel.
-    CU_EGL_COLOR_FORMAT_YVYU_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVYU_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V three channels in one surface, interleaved as
     #: VUY. Only pitch linear format supported.
-    CU_EGL_COLOR_FORMAT_YUV_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUVA_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V, A four channels in one surface, interleaved
     #: as AVUY.
-    CU_EGL_COLOR_FORMAT_YUVA_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_AYUV_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUVA_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V, A four channels in one surface, interleaved
     #: as VUYA.
-    CU_EGL_COLOR_FORMAT_AYUV_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_AYUV_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_AYUV_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V
     #: height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
     #: U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
     #: byte ordering, U/V width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
     #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
     #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V
     #: height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
     #: U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
     #: byte ordering, U/V width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
     #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
     #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved RGGB
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RGGB{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved BGGR
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BGGR{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved GRBG
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GRBG{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved GBRG
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER10_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_GBRG{{endif}}
+    {{if True}}
 
     #: Bayer10 format - one channel in one surface with interleaved RGGB
     #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER10_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER10_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER10_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_RGGB{{endif}}
+    {{if True}}
 
     #: Bayer10 format - one channel in one surface with interleaved BGGR
     #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER10_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER10_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER10_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_BGGR{{endif}}
+    {{if True}}
 
     #: Bayer10 format - one channel in one surface with interleaved GRBG
     #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER10_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER10_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER10_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GRBG{{endif}}
+    {{if True}}
 
     #: Bayer10 format - one channel in one surface with interleaved GBRG
     #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER10_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER10_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_GBRG{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved RGGB
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RGGB{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved BGGR
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BGGR{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved GRBG
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GRBG{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved GBRG
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER14_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_GBRG{{endif}}
+    {{if True}}
 
     #: Bayer14 format - one channel in one surface with interleaved RGGB
     #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER14_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER14_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER14_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_RGGB{{endif}}
+    {{if True}}
 
     #: Bayer14 format - one channel in one surface with interleaved BGGR
     #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER14_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER14_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER14_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_BGGR{{endif}}
+    {{if True}}
 
     #: Bayer14 format - one channel in one surface with interleaved GRBG
     #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER14_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER14_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER14_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GRBG{{endif}}
+    {{if True}}
 
     #: Bayer14 format - one channel in one surface with interleaved GBRG
     #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER14_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER20_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER14_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER14_GBRG{{endif}}
+    {{if True}}
 
     #: Bayer20 format - one channel in one surface with interleaved RGGB
     #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER20_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER20_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER20_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_RGGB{{endif}}
+    {{if True}}
 
     #: Bayer20 format - one channel in one surface with interleaved BGGR
     #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER20_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER20_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER20_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_BGGR{{endif}}
+    {{if True}}
 
     #: Bayer20 format - one channel in one surface with interleaved GRBG
     #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER20_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER20_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER20_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GRBG{{endif}}
+    {{if True}}
 
     #: Bayer20 format - one channel in one surface with interleaved GBRG
     #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER20_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU444_PLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER20_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER20_GBRG{{endif}}
+    {{if True}}
 
     #: Y, V, U in three surfaces, each in a separate surface, U/V width = Y
     #: width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU444_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU422_PLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU444_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU444_PLANAR{{endif}}
+    {{if True}}
 
     #: Y, V, U in three surfaces, each in a separate surface, U/V width =
     #: 1/2 Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_YVU422_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_PLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU422_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU422_PLANAR{{endif}}
+    {{if True}}
 
     #: Y, V, U in three surfaces, each in a separate surface, U/V width =
     #: 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR{{endif}}
+    {{if True}}
 
     #: Nvidia proprietary Bayer ISP format - one channel in one surface
     #: with interleaved RGGB ordering and mapped to opaque integer
     #: datatype.
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB{{endif}}
+    {{if True}}
 
     #: Nvidia proprietary Bayer ISP format - one channel in one surface
     #: with interleaved BGGR ordering and mapped to opaque integer
     #: datatype.
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR{{endif}}
+    {{if True}}
 
     #: Nvidia proprietary Bayer ISP format - one channel in one surface
     #: with interleaved GRBG ordering and mapped to opaque integer
     #: datatype.
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG{{endif}}
+    {{if True}}
 
     #: Nvidia proprietary Bayer ISP format - one channel in one surface
     #: with interleaved GBRG ordering and mapped to opaque integer
     #: datatype.
-    CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_BCCR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved BCCR
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_BCCR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_RCCB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_BCCR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_BCCR{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved RCCB
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_RCCB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_CRBC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_RCCB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_RCCB{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved CRBC
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_CRBC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER_CBRC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_CRBC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CRBC{{endif}}
+    {{if True}}
 
     #: Bayer format - one channel in one surface with interleaved CBRC
     #: ordering.
-    CU_EGL_COLOR_FORMAT_BAYER_CBRC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER10_CCCC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER_CBRC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER_CBRC{{endif}}
+    {{if True}}
 
     #: Bayer10 format - one channel in one surface with interleaved CCCC
     #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER10_CCCC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_BCCR' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER10_CCCC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER10_CCCC{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved BCCR
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_BCCR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_RCCB' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_BCCR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_BCCR{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved RCCB
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_RCCB = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_CRBC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_RCCB = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_RCCB{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved CRBC
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_CRBC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_CBRC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_CRBC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CRBC{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved CBRC
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_CBRC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_BAYER12_CCCC' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_CBRC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CBRC{{endif}}
+    {{if True}}
 
     #: Bayer12 format - one channel in one surface with interleaved CCCC
     #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    CU_EGL_COLOR_FORMAT_BAYER12_CCCC = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y' in found_values}}
+    CU_EGL_COLOR_FORMAT_BAYER12_CCCC = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_BAYER12_CCCC{{endif}}
+    {{if True}}
 
     #: Color format for single Y plane.
-    CU_EGL_COLOR_FORMAT_Y = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y{{endif}}
+    {{if True}}
 
     #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V
     #: height= 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y, V, U each in a separate surface, U/V width = 1/2 Y width, U/V
     #: height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709{{endif}}
+    {{if True}}
 
     #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
     #: U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709{{endif}}
+    {{if True}}
 
     #: Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V
     #: height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709{{endif}}
+    {{if True}}
 
     #: Y, V, U each in a separate surface, U/V width = 1/2 Y width, U/V
     #: height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces (VU as one surface), U/V width = 1/2 Y
     #: width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces (VU as one surface), U/V width = 1/2 Y
     #: width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y
     #: width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y
     #: width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR{{endif}}
+    {{if True}}
 
     #: Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y
     #: width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709 = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y plane.
-    CU_EGL_COLOR_FORMAT_Y_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y plane.
-    CU_EGL_COLOR_FORMAT_Y_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y_709_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y10 plane.
-    CU_EGL_COLOR_FORMAT_Y10_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y10 plane.
-    CU_EGL_COLOR_FORMAT_Y10_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10_709_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y12 plane.
-    CU_EGL_COLOR_FORMAT_Y12_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Color format for single Y12 plane.
-    CU_EGL_COLOR_FORMAT_Y12_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUVA' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12_709_ER{{endif}}
+    {{if True}}
 
     #: Y, U, V, A four channels in one surface, interleaved as AVUY.
-    CU_EGL_COLOR_FORMAT_YUVA = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YUV' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUVA = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUVA{{endif}}
+    {{if True}}
 
     #: Y, U, V three channels in one surface, interleaved as VUY. Only
     #: pitch linear format supported.
-    CU_EGL_COLOR_FORMAT_YUV = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_YVYU' in found_values}}
+    CU_EGL_COLOR_FORMAT_YUV = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YUV{{endif}}
+    {{if True}}
 
     #: Y, U, V in one surface, interleaved as YVYU in one channel.
-    CU_EGL_COLOR_FORMAT_YVYU = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_VYUY' in found_values}}
+    CU_EGL_COLOR_FORMAT_YVYU = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_YVYU{{endif}}
+    {{if True}}
 
     #: Y, U, V in one surface, interleaved as VYUY in one channel.
-    CU_EGL_COLOR_FORMAT_VYUY = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_VYUY = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_VYUY{{endif}}
+    {{if True}}
 
     #: Extended Range Y10, V10U10 in two surfaces(VU as one surface) U/V
     #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y10, V10U10 in two surfaces(VU as one surface) U/V
     #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
     #: width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
     #: width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
     #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
     #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
     #: width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER' in found_values}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER{{endif}}
+    {{if True}}
 
     #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
     #: width = Y width, U/V height = Y height.
-    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER{{endif}}
-    {{if True or 'CU_EGL_COLOR_FORMAT_MAX' in found_values}}
-    CU_EGL_COLOR_FORMAT_MAX = ccuda.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_MAX{{endif}}
+    CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER{{endif}}
+    {{if True}}
+    CU_EGL_COLOR_FORMAT_MAX = cydriver.CUeglColorFormat_enum.CU_EGL_COLOR_FORMAT_MAX{{endif}}
 {{endif}}
-{{if True or 'CUGLDeviceList_enum' in found_types}}
+{{if True}}
 
 class CUGLDeviceList(IntEnum):
     """
     CUDA devices corresponding to an OpenGL device
     """
-    {{if True or 'CU_GL_DEVICE_LIST_ALL' in found_values}}
+    {{if True}}
 
     #: The CUDA devices for all GPUs used by the current OpenGL context
-    CU_GL_DEVICE_LIST_ALL = ccuda.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_ALL{{endif}}
-    {{if True or 'CU_GL_DEVICE_LIST_CURRENT_FRAME' in found_values}}
+    CU_GL_DEVICE_LIST_ALL = cydriver.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_ALL{{endif}}
+    {{if True}}
 
     #: The CUDA devices for the GPUs used by the current OpenGL context in
     #: its currently rendering frame
-    CU_GL_DEVICE_LIST_CURRENT_FRAME = ccuda.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_CURRENT_FRAME{{endif}}
-    {{if True or 'CU_GL_DEVICE_LIST_NEXT_FRAME' in found_values}}
+    CU_GL_DEVICE_LIST_CURRENT_FRAME = cydriver.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_CURRENT_FRAME{{endif}}
+    {{if True}}
 
     #: The CUDA devices for the GPUs to be used by the current OpenGL
     #: context in the next frame
-    CU_GL_DEVICE_LIST_NEXT_FRAME = ccuda.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_NEXT_FRAME{{endif}}
+    CU_GL_DEVICE_LIST_NEXT_FRAME = cydriver.CUGLDeviceList_enum.CU_GL_DEVICE_LIST_NEXT_FRAME{{endif}}
 {{endif}}
-{{if True or 'CUGLmap_flags_enum' in found_types}}
+{{if True}}
 
 class CUGLmap_flags(IntEnum):
     """
     Flags to map or unmap a resource
     """
-    {{if True or 'CU_GL_MAP_RESOURCE_FLAGS_NONE' in found_values}}
-    CU_GL_MAP_RESOURCE_FLAGS_NONE = ccuda.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_NONE{{endif}}
-    {{if True or 'CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY' in found_values}}
-    CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = ccuda.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
-    {{if True or 'CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD' in found_values}}
-    CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = ccuda.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
+    {{if True}}
+    CU_GL_MAP_RESOURCE_FLAGS_NONE = cydriver.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_NONE{{endif}}
+    {{if True}}
+    CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY = cydriver.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY{{endif}}
+    {{if True}}
+    CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD = cydriver.CUGLmap_flags_enum.CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD{{endif}}
 {{endif}}
-{{if 'CUcontext' in found_types}}
+{{if 'CUdeviceptr' in found_types}}
 
-cdef class CUcontext:
+cdef class CUdeviceptr:
     """
 
-    CUDA context
+    CUDA device pointer CUdeviceptr is defined as an unsigned integer type whose size matches the size of a pointer on the target platform.
 
     Methods
     -------
@@ -4658,30 +4539,29 @@ cdef class CUcontext:
         Get memory address of class instance
 
     """
-    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUcontext>init_value
         else:
-            self._ptr = <ccuda.CUcontext *>_ptr
-    def __init__(self, *args, **kwargs):
+            self._ptr = <cydriver.CUdeviceptr *>_ptr
+        if init_value:
+            self._ptr[0] = init_value
+    def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<CUcontext ' + str(hex(self.__int__())) + '>'
-    def __index__(self):
-        return self.__int__()
+        return '<CUdeviceptr ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <void_ptr>self._ptr[0]
+        return <unsigned long long>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUmodule' in found_types}}
+{{if 'CUdevice' in found_types}}
 
-cdef class CUmodule:
+cdef class CUdevice:
     """
 
-    CUDA module
+    CUDA device
 
     Methods
     -------
@@ -4689,30 +4569,29 @@ cdef class CUmodule:
         Get memory address of class instance
 
     """
-    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, int init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUmodule>init_value
         else:
-            self._ptr = <ccuda.CUmodule *>_ptr
-    def __init__(self, *args, **kwargs):
+            self._ptr = <cydriver.CUdevice *>_ptr
+        if init_value:
+            self._ptr[0] = init_value
+    def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<CUmodule ' + str(hex(self.__int__())) + '>'
-    def __index__(self):
-        return self.__int__()
+        return '<CUdevice ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <void_ptr>self._ptr[0]
+        return <int>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUfunction' in found_types}}
+{{if 'CUtexObject' in found_types}}
 
-cdef class CUfunction:
+cdef class CUtexObject:
     """
 
-    CUDA function
+    An opaque value that represents a CUDA texture object
 
     Methods
     -------
@@ -4720,17 +4599,287 @@ cdef class CUfunction:
         Get memory address of class instance
 
     """
-    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUfunction>init_value
         else:
-            self._ptr = <ccuda.CUfunction *>_ptr
-    def __init__(self, *args, **kwargs):
+            self._ptr = <cydriver.CUtexObject *>_ptr
+        if init_value:
+            self._ptr[0] = init_value
+    def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<CUfunction ' + str(hex(self.__int__())) + '>'
-    def __index__(self):
+        return '<CUtexObject ' + str(self.__int__()) + '>'
+    def __int__(self):
+        return <unsigned long long>self._ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._ptr
+{{endif}}
+
+{{if 'CUsurfObject' in found_types}}
+
+cdef class CUsurfObject:
+    """
+
+    An opaque value that represents a CUDA surface object
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._ptr = &self.__val
+        else:
+            self._ptr = <cydriver.CUsurfObject *>_ptr
+        if init_value:
+            self._ptr[0] = init_value
+    def __dealloc__(self):
+        pass
+    def __repr__(self):
+        return '<CUsurfObject ' + str(self.__int__()) + '>'
+    def __int__(self):
+        return <unsigned long long>self._ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._ptr
+{{endif}}
+
+{{if 'CUlaunchAttributeID_enum' in found_types}}
+
+class CUkernelNodeAttrID(IntEnum):
+    """
+
+    """
+    {{if 'CU_LAUNCH_ATTRIBUTE_IGNORE' in found_values}}
+
+    #: Ignored entry, for convenient composition
+    CU_LAUNCH_ATTRIBUTE_IGNORE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW' in found_values}}
+
+    #: Valid for streams, graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_COOPERATIVE' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY' in found_values}}
+
+    #: Valid for streams.
+    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION' in found_values}}
+
+    #: Valid for launches. Setting programmaticStreamSerializationAllowed
+    #: to non-0 signals that the kernel will use programmatic means to
+    #: resolve its stream dependency, so that the CUDA runtime should
+    #: opportunistically allow the grid's execution to overlap with the
+    #: previous kernel in the stream, if that kernel requests the overlap.
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT' in found_values}}
+
+    #: Valid for launches. Event recorded through this launch attribute is
+    #: guaranteed to only trigger after all block in the associated kernel
+    #: trigger the event. A block can trigger the event through PTX
+    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
+    #: the beginning of each block's execution if triggerAtBlockStart is
+    #: set to non-0. Note that dependents (including the CPU thread calling
+    #: :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the
+    #: release precisely when it is released. For example,
+    #: :py:obj:`~.cuEventSynchronize()` may only observe the event trigger
+    #: long after the associated kernel has completed. This recording type
+    #: is primarily meant for establishing programmatic dependency between
+    #: device tasks. The event supplied must not be an interprocess or
+    #: interop event. The event must disable timing (i.e. created with
+    #: :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PRIORITY' in found_values}}
+
+    #: Valid for graph nodes.
+    CU_LAUNCH_ATTRIBUTE_PRIORITY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
+{{endif}}
+{{if 'CUlaunchAttributeID_enum' in found_types}}
+
+class CUstreamAttrID(IntEnum):
+    """
+
+    """
+    {{if 'CU_LAUNCH_ATTRIBUTE_IGNORE' in found_values}}
+
+    #: Ignored entry, for convenient composition
+    CU_LAUNCH_ATTRIBUTE_IGNORE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_IGNORE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW' in found_values}}
+
+    #: Valid for streams, graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_COOPERATIVE' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_COOPERATIVE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_COOPERATIVE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY' in found_values}}
+
+    #: Valid for streams.
+    CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION' in found_values}}
+
+    #: Valid for launches. Setting programmaticStreamSerializationAllowed
+    #: to non-0 signals that the kernel will use programmatic means to
+    #: resolve its stream dependency, so that the CUDA runtime should
+    #: opportunistically allow the grid's execution to overlap with the
+    #: previous kernel in the stream, if that kernel requests the overlap.
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT' in found_values}}
+
+    #: Valid for launches. Event recorded through this launch attribute is
+    #: guaranteed to only trigger after all block in the associated kernel
+    #: trigger the event. A block can trigger the event through PTX
+    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
+    #: the beginning of each block's execution if triggerAtBlockStart is
+    #: set to non-0. Note that dependents (including the CPU thread calling
+    #: :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the
+    #: release precisely when it is released. For example,
+    #: :py:obj:`~.cuEventSynchronize()` may only observe the event trigger
+    #: long after the associated kernel has completed. This recording type
+    #: is primarily meant for establishing programmatic dependency between
+    #: device tasks. The event supplied must not be an interprocess or
+    #: interop event. The event must disable timing (i.e. created with
+    #: :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
+    CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT{{endif}}
+    {{if 'CU_LAUNCH_ATTRIBUTE_PRIORITY' in found_values}}
+
+    #: Valid for graph nodes.
+    CU_LAUNCH_ATTRIBUTE_PRIORITY = cydriver.CUlaunchAttributeID_enum.CU_LAUNCH_ATTRIBUTE_PRIORITY{{endif}}
+{{endif}}
+{{if 'CUmemGenericAllocationHandle' in found_types}}
+
+cdef class CUmemGenericAllocationHandle:
+    """
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._ptr = &self.__val
+        else:
+            self._ptr = <cydriver.CUmemGenericAllocationHandle *>_ptr
+        if init_value:
+            self._ptr[0] = init_value
+    def __dealloc__(self):
+        pass
+    def __repr__(self):
+        return '<CUmemGenericAllocationHandle ' + str(self.__int__()) + '>'
+    def __int__(self):
+        return <unsigned long long>self._ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._ptr
+{{endif}}
+
+{{if 'CUcontext' in found_types}}
+
+cdef class CUcontext:
+    """
+
+    CUDA context
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._ptr = &self.__val
+            self._ptr[0] = <cydriver.CUcontext>init_value
+        else:
+            self._ptr = <cydriver.CUcontext *>_ptr
+    def __init__(self, *args, **kwargs):
+        pass
+    def __repr__(self):
+        return '<CUcontext ' + str(hex(self.__int__())) + '>'
+    def __index__(self):
+        return self.__int__()
+    def __int__(self):
+        return <void_ptr>self._ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._ptr
+{{endif}}
+
+{{if 'CUmodule' in found_types}}
+
+cdef class CUmodule:
+    """
+
+    CUDA module
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._ptr = &self.__val
+            self._ptr[0] = <cydriver.CUmodule>init_value
+        else:
+            self._ptr = <cydriver.CUmodule *>_ptr
+    def __init__(self, *args, **kwargs):
+        pass
+    def __repr__(self):
+        return '<CUmodule ' + str(hex(self.__int__())) + '>'
+    def __index__(self):
+        return self.__int__()
+    def __int__(self):
+        return <void_ptr>self._ptr[0]
+    def getPtr(self):
+        return <void_ptr>self._ptr
+{{endif}}
+
+{{if 'CUfunction' in found_types}}
+
+cdef class CUfunction:
+    """
+
+    CUDA function
+
+    Methods
+    -------
+    getPtr()
+        Get memory address of class instance
+
+    """
+    def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
+        if _ptr == 0:
+            self._ptr = &self.__val
+            self._ptr[0] = <cydriver.CUfunction>init_value
+        else:
+            self._ptr = <cydriver.CUfunction *>_ptr
+    def __init__(self, *args, **kwargs):
+        pass
+    def __repr__(self):
+        return '<CUfunction ' + str(hex(self.__int__())) + '>'
+    def __index__(self):
         return self.__int__()
     def __int__(self):
         return <void_ptr>self._ptr[0]
@@ -4754,9 +4903,9 @@ cdef class CUarray:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUarray>init_value
+            self._ptr[0] = <cydriver.CUarray>init_value
         else:
-            self._ptr = <ccuda.CUarray *>_ptr
+            self._ptr = <cydriver.CUarray *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4785,9 +4934,9 @@ cdef class CUmipmappedArray:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUmipmappedArray>init_value
+            self._ptr[0] = <cydriver.CUmipmappedArray>init_value
         else:
-            self._ptr = <ccuda.CUmipmappedArray *>_ptr
+            self._ptr = <cydriver.CUmipmappedArray *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4816,9 +4965,9 @@ cdef class CUtexref:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUtexref>init_value
+            self._ptr[0] = <cydriver.CUtexref>init_value
         else:
-            self._ptr = <ccuda.CUtexref *>_ptr
+            self._ptr = <cydriver.CUtexref *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4847,9 +4996,9 @@ cdef class CUsurfref:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUsurfref>init_value
+            self._ptr[0] = <cydriver.CUsurfref>init_value
         else:
-            self._ptr = <ccuda.CUsurfref *>_ptr
+            self._ptr = <cydriver.CUsurfref *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4878,9 +5027,9 @@ cdef class CUevent:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUevent>init_value
+            self._ptr[0] = <cydriver.CUevent>init_value
         else:
-            self._ptr = <ccuda.CUevent *>_ptr
+            self._ptr = <cydriver.CUevent *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4909,9 +5058,9 @@ cdef class CUstream:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUstream>init_value
+            self._ptr[0] = <cydriver.CUstream>init_value
         else:
-            self._ptr = <ccuda.CUstream *>_ptr
+            self._ptr = <cydriver.CUstream *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4940,9 +5089,9 @@ cdef class CUgraphicsResource:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUgraphicsResource>init_value
+            self._ptr[0] = <cydriver.CUgraphicsResource>init_value
         else:
-            self._ptr = <ccuda.CUgraphicsResource *>_ptr
+            self._ptr = <cydriver.CUgraphicsResource *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4971,9 +5120,9 @@ cdef class CUexternalMemory:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUexternalMemory>init_value
+            self._ptr[0] = <cydriver.CUexternalMemory>init_value
         else:
-            self._ptr = <ccuda.CUexternalMemory *>_ptr
+            self._ptr = <cydriver.CUexternalMemory *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5002,9 +5151,9 @@ cdef class CUexternalSemaphore:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUexternalSemaphore>init_value
+            self._ptr[0] = <cydriver.CUexternalSemaphore>init_value
         else:
-            self._ptr = <ccuda.CUexternalSemaphore *>_ptr
+            self._ptr = <cydriver.CUexternalSemaphore *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5033,9 +5182,9 @@ cdef class CUgraph:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUgraph>init_value
+            self._ptr[0] = <cydriver.CUgraph>init_value
         else:
-            self._ptr = <ccuda.CUgraph *>_ptr
+            self._ptr = <cydriver.CUgraph *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5064,9 +5213,9 @@ cdef class CUgraphNode:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUgraphNode>init_value
+            self._ptr[0] = <cydriver.CUgraphNode>init_value
         else:
-            self._ptr = <ccuda.CUgraphNode *>_ptr
+            self._ptr = <cydriver.CUgraphNode *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5095,9 +5244,9 @@ cdef class CUgraphExec:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUgraphExec>init_value
+            self._ptr[0] = <cydriver.CUgraphExec>init_value
         else:
-            self._ptr = <ccuda.CUgraphExec *>_ptr
+            self._ptr = <cydriver.CUgraphExec *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5126,9 +5275,9 @@ cdef class CUmemoryPool:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUmemoryPool>init_value
+            self._ptr[0] = <cydriver.CUmemoryPool>init_value
         else:
-            self._ptr = <ccuda.CUmemoryPool *>_ptr
+            self._ptr = <cydriver.CUmemoryPool *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5157,9 +5306,9 @@ cdef class CUuserObject:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUuserObject>init_value
+            self._ptr[0] = <cydriver.CUuserObject>init_value
         else:
-            self._ptr = <ccuda.CUuserObject *>_ptr
+            self._ptr = <cydriver.CUuserObject *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5186,9 +5335,9 @@ cdef class CUlinkState:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUlinkState>init_value
+            self._ptr[0] = <cydriver.CUlinkState>init_value
         else:
-            self._ptr = <ccuda.CUlinkState *>_ptr
+            self._ptr = <cydriver.CUlinkState *>_ptr
     def __init__(self, *args, **kwargs):
         self._keepalive = []
     def __repr__(self):
@@ -5201,11 +5350,13 @@ cdef class CUlinkState:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLImageKHR' in found_types}}
+{{if True}}
 
-cdef class EGLImageKHR:
+cdef class CUeglStreamConnection:
     """
 
+    CUDA EGLSream Connection
+
     Methods
     -------
     getPtr()
@@ -5215,13 +5366,13 @@ cdef class EGLImageKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.EGLImageKHR>init_value
+            self._ptr[0] = <cydriver.CUeglStreamConnection>init_value
         else:
-            self._ptr = <ccuda.EGLImageKHR *>_ptr
+            self._ptr = <cydriver.CUeglStreamConnection *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
-        return '<EGLImageKHR ' + str(hex(self.__int__())) + '>'
+        return '<CUeglStreamConnection ' + str(hex(self.__int__())) + '>'
     def __index__(self):
         return self.__int__()
     def __int__(self):
@@ -5230,9 +5381,9 @@ cdef class EGLImageKHR:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLStreamKHR' in found_types}}
+{{if True}}
 
-cdef class EGLStreamKHR:
+cdef class EGLImageKHR:
     """
 
     Methods
@@ -5244,13 +5395,13 @@ cdef class EGLStreamKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.EGLStreamKHR>init_value
+            self._ptr[0] = <cydriver.EGLImageKHR>init_value
         else:
-            self._ptr = <ccuda.EGLStreamKHR *>_ptr
+            self._ptr = <cydriver.EGLImageKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
-        return '<EGLStreamKHR ' + str(hex(self.__int__())) + '>'
+        return '<EGLImageKHR ' + str(hex(self.__int__())) + '>'
     def __index__(self):
         return self.__int__()
     def __int__(self):
@@ -5259,9 +5410,9 @@ cdef class EGLStreamKHR:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLSyncKHR' in found_types}}
+{{if True}}
 
-cdef class EGLSyncKHR:
+cdef class EGLStreamKHR:
     """
 
     Methods
@@ -5273,13 +5424,13 @@ cdef class EGLSyncKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.EGLSyncKHR>init_value
+            self._ptr[0] = <cydriver.EGLStreamKHR>init_value
         else:
-            self._ptr = <ccuda.EGLSyncKHR *>_ptr
+            self._ptr = <cydriver.EGLStreamKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
-        return '<EGLSyncKHR ' + str(hex(self.__int__())) + '>'
+        return '<EGLStreamKHR ' + str(hex(self.__int__())) + '>'
     def __index__(self):
         return self.__int__()
     def __int__(self):
@@ -5288,13 +5439,11 @@ cdef class EGLSyncKHR:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'CUeglStreamConnection' in found_types}}
+{{if True}}
 
-cdef class CUeglStreamConnection:
+cdef class EGLSyncKHR:
     """
 
-    CUDA EGLSream Connection
-
     Methods
     -------
     getPtr()
@@ -5304,13 +5453,13 @@ cdef class CUeglStreamConnection:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUeglStreamConnection>init_value
+            self._ptr[0] = <cydriver.EGLSyncKHR>init_value
         else:
-            self._ptr = <ccuda.CUeglStreamConnection *>_ptr
+            self._ptr = <cydriver.EGLSyncKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
-        return '<CUeglStreamConnection ' + str(hex(self.__int__())) + '>'
+        return '<EGLSyncKHR ' + str(hex(self.__int__())) + '>'
     def __index__(self):
         return self.__int__()
     def __int__(self):
@@ -5333,9 +5482,9 @@ cdef class CUhostFn:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUhostFn>init_value
+            self._ptr[0] = <cydriver.CUhostFn>init_value
         else:
-            self._ptr = <ccuda.CUhostFn *>_ptr
+            self._ptr = <cydriver.CUhostFn *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5362,9 +5511,9 @@ cdef class CUstreamCallback:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUstreamCallback>init_value
+            self._ptr[0] = <cydriver.CUstreamCallback>init_value
         else:
-            self._ptr = <ccuda.CUstreamCallback *>_ptr
+            self._ptr = <cydriver.CUstreamCallback *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5391,9 +5540,9 @@ cdef class CUoccupancyB2DSize:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccuda.CUoccupancyB2DSize>init_value
+            self._ptr[0] = <cydriver.CUoccupancyB2DSize>init_value
         else:
-            self._ptr = <ccuda.CUoccupancyB2DSize *>_ptr
+            self._ptr = <cydriver.CUoccupancyB2DSize *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -5406,11 +5555,10 @@ cdef class CUoccupancyB2DSize:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUuuid_st' in found_types}}
+{{if 'struct CUuuid_st' in found_types}}
 
 cdef class CUuuid_st:
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -5426,7 +5574,7 @@ cdef class CUuuid_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUuuid_st *>_ptr
+            self._ptr = <cydriver.CUuuid_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5436,16 +5584,19 @@ cdef class CUuuid_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['bytes : ' + str(self.bytes.hex())]
+            try:
+                str_list += ['bytes : ' + str(self.bytes.hex())]
+            except ValueError:
+                str_list += ['bytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def bytes(self):
         return PyBytes_FromStringAndSize(self._ptr[0].bytes, 16)
+
 {{endif}}
-{{if 'CUipcEventHandle_st' in found_types}}
+{{if 'struct CUipcEventHandle_st' in found_types}}
 
 cdef class CUipcEventHandle_st:
     """
@@ -5466,7 +5617,7 @@ cdef class CUipcEventHandle_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUipcEventHandle_st *>_ptr
+            self._ptr = <cydriver.CUipcEventHandle_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5476,11 +5627,13 @@ cdef class CUipcEventHandle_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(self._ptr[0].reserved, 64)
@@ -5499,7 +5652,7 @@ cdef class CUipcEventHandle_st:
                     b = b - 256
                 self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'CUipcMemHandle_st' in found_types}}
+{{if 'struct CUipcMemHandle_st' in found_types}}
 
 cdef class CUipcMemHandle_st:
     """
@@ -5520,7 +5673,7 @@ cdef class CUipcMemHandle_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUipcMemHandle_st *>_ptr
+            self._ptr = <cydriver.CUipcMemHandle_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5530,11 +5683,13 @@ cdef class CUipcMemHandle_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(self._ptr[0].reserved, 64)
@@ -5553,17 +5708,18 @@ cdef class CUipcMemHandle_st:
                     b = b - 256
                 self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpWaitValueParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
 
     address : CUdeviceptr
 
+    value : cuuint32_t
+
     value64 : cuuint64_t
 
     flags : unsigned int
@@ -5578,96 +5734,136 @@ cdef class CUstreamMemOpWaitValueParams_st:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUstreamBatchMemOpParams_union *>_ptr
+        self._ptr = <cydriver.CUstreamBatchMemOpParams_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._address = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].waitValue.address)
+        self._value = cuuint32_t(_ptr=<void_ptr>&self._ptr[0].waitValue.value)
         self._value64 = cuuint64_t(_ptr=<void_ptr>&self._ptr[0].waitValue.value64)
         self._alias = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].waitValue.alias)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].waitValue
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['operation : ' + str(self.operation)]
-            str_list += ['address : ' + str(self.address)]
-            str_list += ['value64 : ' + str(self.value64)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['alias : ' + str(self.alias)]
+            try:
+                str_list += ['operation : ' + str(self.operation)]
+            except ValueError:
+                str_list += ['operation : <ValueError>']
+            try:
+                str_list += ['address : ' + str(self.address)]
+            except ValueError:
+                str_list += ['address : <ValueError>']
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
+            try:
+                str_list += ['value64 : ' + str(self.value64)]
+            except ValueError:
+                str_list += ['value64 : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['alias : ' + str(self.alias)]
+            except ValueError:
+                str_list += ['alias : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def operation(self):
         return CUstreamBatchMemOpType(self._ptr[0].waitValue.operation)
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
-        pass
         self._ptr[0].waitValue.operation = operation.value
     @property
     def address(self):
         return self._address
     @address.setter
     def address(self, address):
-        cdef ccuda.CUdeviceptr caddress
+        cdef cydriver.CUdeviceptr cyaddress
         if address is None:
-            caddress = <ccuda.CUdeviceptr><void_ptr>0
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(address, (CUdeviceptr)):
             paddress = int(address)
-            caddress = <ccuda.CUdeviceptr><void_ptr>paddress
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>paddress
         else:
             paddress = int(CUdeviceptr(address))
-            caddress = <ccuda.CUdeviceptr><void_ptr>paddress
-        self._address._ptr[0] = caddress
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>paddress
+        self._address._ptr[0] = cyaddress
+
+    @property
+    def value(self):
+        return self._value
+    @value.setter
+    def value(self, value):
+        cdef cydriver.cuuint32_t cyvalue
+        if value is None:
+            cyvalue = <cydriver.cuuint32_t><void_ptr>0
+        elif isinstance(value, (cuuint32_t)):
+            pvalue = int(value)
+            cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+        else:
+            pvalue = int(cuuint32_t(value))
+            cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+        self._value._ptr[0] = cyvalue
+
     @property
     def value64(self):
         return self._value64
     @value64.setter
     def value64(self, value64):
-        cdef ccuda.cuuint64_t cvalue64
+        cdef cydriver.cuuint64_t cyvalue64
         if value64 is None:
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>0
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>0
         elif isinstance(value64, (cuuint64_t)):
             pvalue64 = int(value64)
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>pvalue64
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>pvalue64
         else:
             pvalue64 = int(cuuint64_t(value64))
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>pvalue64
-        self._value64._ptr[0] = cvalue64
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>pvalue64
+        self._value64._ptr[0] = cyvalue64
+
     @property
     def flags(self):
         return self._ptr[0].waitValue.flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].waitValue.flags = flags
     @property
     def alias(self):
         return self._alias
     @alias.setter
     def alias(self, alias):
-        cdef ccuda.CUdeviceptr calias
+        cdef cydriver.CUdeviceptr cyalias
         if alias is None:
-            calias = <ccuda.CUdeviceptr><void_ptr>0
+            cyalias = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(alias, (CUdeviceptr)):
             palias = int(alias)
-            calias = <ccuda.CUdeviceptr><void_ptr>palias
+            cyalias = <cydriver.CUdeviceptr><void_ptr>palias
         else:
             palias = int(CUdeviceptr(alias))
-            calias = <ccuda.CUdeviceptr><void_ptr>palias
-        self._alias._ptr[0] = calias
+            cyalias = <cydriver.CUdeviceptr><void_ptr>palias
+        self._alias._ptr[0] = cyalias
+
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpWriteValueParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
 
     address : CUdeviceptr
 
+    value : cuuint32_t
+
     value64 : cuuint64_t
 
     flags : unsigned int
@@ -5682,90 +5878,128 @@ cdef class CUstreamMemOpWriteValueParams_st:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUstreamBatchMemOpParams_union *>_ptr
+        self._ptr = <cydriver.CUstreamBatchMemOpParams_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._address = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].writeValue.address)
+        self._value = cuuint32_t(_ptr=<void_ptr>&self._ptr[0].writeValue.value)
         self._value64 = cuuint64_t(_ptr=<void_ptr>&self._ptr[0].writeValue.value64)
         self._alias = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].writeValue.alias)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].writeValue
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['operation : ' + str(self.operation)]
-            str_list += ['address : ' + str(self.address)]
-            str_list += ['value64 : ' + str(self.value64)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['alias : ' + str(self.alias)]
+            try:
+                str_list += ['operation : ' + str(self.operation)]
+            except ValueError:
+                str_list += ['operation : <ValueError>']
+            try:
+                str_list += ['address : ' + str(self.address)]
+            except ValueError:
+                str_list += ['address : <ValueError>']
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
+            try:
+                str_list += ['value64 : ' + str(self.value64)]
+            except ValueError:
+                str_list += ['value64 : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['alias : ' + str(self.alias)]
+            except ValueError:
+                str_list += ['alias : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def operation(self):
         return CUstreamBatchMemOpType(self._ptr[0].writeValue.operation)
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
-        pass
         self._ptr[0].writeValue.operation = operation.value
     @property
     def address(self):
         return self._address
     @address.setter
     def address(self, address):
-        cdef ccuda.CUdeviceptr caddress
+        cdef cydriver.CUdeviceptr cyaddress
         if address is None:
-            caddress = <ccuda.CUdeviceptr><void_ptr>0
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(address, (CUdeviceptr)):
             paddress = int(address)
-            caddress = <ccuda.CUdeviceptr><void_ptr>paddress
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>paddress
         else:
             paddress = int(CUdeviceptr(address))
-            caddress = <ccuda.CUdeviceptr><void_ptr>paddress
-        self._address._ptr[0] = caddress
+            cyaddress = <cydriver.CUdeviceptr><void_ptr>paddress
+        self._address._ptr[0] = cyaddress
+
+    @property
+    def value(self):
+        return self._value
+    @value.setter
+    def value(self, value):
+        cdef cydriver.cuuint32_t cyvalue
+        if value is None:
+            cyvalue = <cydriver.cuuint32_t><void_ptr>0
+        elif isinstance(value, (cuuint32_t)):
+            pvalue = int(value)
+            cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+        else:
+            pvalue = int(cuuint32_t(value))
+            cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+        self._value._ptr[0] = cyvalue
+
     @property
     def value64(self):
         return self._value64
     @value64.setter
     def value64(self, value64):
-        cdef ccuda.cuuint64_t cvalue64
+        cdef cydriver.cuuint64_t cyvalue64
         if value64 is None:
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>0
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>0
         elif isinstance(value64, (cuuint64_t)):
             pvalue64 = int(value64)
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>pvalue64
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>pvalue64
         else:
             pvalue64 = int(cuuint64_t(value64))
-            cvalue64 = <ccuda.cuuint64_t><void_ptr>pvalue64
-        self._value64._ptr[0] = cvalue64
+            cyvalue64 = <cydriver.cuuint64_t><void_ptr>pvalue64
+        self._value64._ptr[0] = cyvalue64
+
     @property
     def flags(self):
         return self._ptr[0].writeValue.flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].writeValue.flags = flags
     @property
     def alias(self):
         return self._alias
     @alias.setter
     def alias(self, alias):
-        cdef ccuda.CUdeviceptr calias
+        cdef cydriver.CUdeviceptr cyalias
         if alias is None:
-            calias = <ccuda.CUdeviceptr><void_ptr>0
+            cyalias = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(alias, (CUdeviceptr)):
             palias = int(alias)
-            calias = <ccuda.CUdeviceptr><void_ptr>palias
+            cyalias = <cydriver.CUdeviceptr><void_ptr>palias
         else:
             palias = int(CUdeviceptr(alias))
-            calias = <ccuda.CUdeviceptr><void_ptr>palias
-        self._alias._ptr[0] = calias
+            cyalias = <cydriver.CUdeviceptr><void_ptr>palias
+        self._alias._ptr[0] = cyalias
+
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpFlushRemoteWritesParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
@@ -5780,40 +6014,45 @@ cdef class CUstreamMemOpFlushRemoteWritesParams_st:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUstreamBatchMemOpParams_union *>_ptr
+        self._ptr = <cydriver.CUstreamBatchMemOpParams_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].flushRemoteWrites
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['operation : ' + str(self.operation)]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['operation : ' + str(self.operation)]
+            except ValueError:
+                str_list += ['operation : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def operation(self):
         return CUstreamBatchMemOpType(self._ptr[0].flushRemoteWrites.operation)
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
-        pass
         self._ptr[0].flushRemoteWrites.operation = operation.value
     @property
     def flags(self):
         return self._ptr[0].flushRemoteWrites.flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flushRemoteWrites.flags = flags
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamMemOpMemoryBarrierParams_st:
     """
-
     Attributes
     ----------
     operation : CUstreamBatchMemOpType
@@ -5828,36 +6067,42 @@ cdef class CUstreamMemOpMemoryBarrierParams_st:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUstreamBatchMemOpParams_union *>_ptr
+        self._ptr = <cydriver.CUstreamBatchMemOpParams_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].memoryBarrier
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['operation : ' + str(self.operation)]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['operation : ' + str(self.operation)]
+            except ValueError:
+                str_list += ['operation : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def operation(self):
         return CUstreamBatchMemOpType(self._ptr[0].memoryBarrier.operation)
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
-        pass
         self._ptr[0].memoryBarrier.operation = operation.value
     @property
     def flags(self):
         return self._ptr[0].memoryBarrier.flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].memoryBarrier.flags = flags
 {{endif}}
-{{if 'CUstreamBatchMemOpParams_union' in found_types}}
+{{if 'union CUstreamBatchMemOpParams_union' in found_types}}
 
 cdef class CUstreamBatchMemOpParams_union:
     """
@@ -5888,12 +6133,12 @@ cdef class CUstreamBatchMemOpParams_union:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUstreamBatchMemOpParams_union *>_ptr
+            self._ptr = <cydriver.CUstreamBatchMemOpParams_union *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._waitValue = CUstreamMemOpWaitValueParams_st(_ptr=<void_ptr>&self._ptr[0].waitValue)
-        self._writeValue = CUstreamMemOpWriteValueParams_st(_ptr=<void_ptr>&self._ptr[0].writeValue)
-        self._flushRemoteWrites = CUstreamMemOpFlushRemoteWritesParams_st(_ptr=<void_ptr>&self._ptr[0].flushRemoteWrites)
-        self._memoryBarrier = CUstreamMemOpMemoryBarrierParams_st(_ptr=<void_ptr>&self._ptr[0].memoryBarrier)
+        self._waitValue = CUstreamMemOpWaitValueParams_st(_ptr=<void_ptr>self._ptr)
+        self._writeValue = CUstreamMemOpWriteValueParams_st(_ptr=<void_ptr>self._ptr)
+        self._flushRemoteWrites = CUstreamMemOpFlushRemoteWritesParams_st(_ptr=<void_ptr>self._ptr)
+        self._memoryBarrier = CUstreamMemOpMemoryBarrierParams_st(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -5901,80 +6146,75 @@ cdef class CUstreamBatchMemOpParams_union:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['operation : ' + str(self.operation)]
-            str_list += ['waitValue :\n' + '\n'.join(['    ' + line for line in str(self.waitValue).splitlines()])]
-            str_list += ['writeValue :\n' + '\n'.join(['    ' + line for line in str(self.writeValue).splitlines()])]
-            str_list += ['flushRemoteWrites :\n' + '\n'.join(['    ' + line for line in str(self.flushRemoteWrites).splitlines()])]
-            str_list += ['memoryBarrier :\n' + '\n'.join(['    ' + line for line in str(self.memoryBarrier).splitlines()])]
-            str_list += ['pad : ' + str(self.pad)]
+            try:
+                str_list += ['operation : ' + str(self.operation)]
+            except ValueError:
+                str_list += ['operation : <ValueError>']
+            try:
+                str_list += ['waitValue :\n' + '\n'.join(['    ' + line for line in str(self.waitValue).splitlines()])]
+            except ValueError:
+                str_list += ['waitValue : <ValueError>']
+            try:
+                str_list += ['writeValue :\n' + '\n'.join(['    ' + line for line in str(self.writeValue).splitlines()])]
+            except ValueError:
+                str_list += ['writeValue : <ValueError>']
+            try:
+                str_list += ['flushRemoteWrites :\n' + '\n'.join(['    ' + line for line in str(self.flushRemoteWrites).splitlines()])]
+            except ValueError:
+                str_list += ['flushRemoteWrites : <ValueError>']
+            try:
+                str_list += ['memoryBarrier :\n' + '\n'.join(['    ' + line for line in str(self.memoryBarrier).splitlines()])]
+            except ValueError:
+                str_list += ['memoryBarrier : <ValueError>']
+            try:
+                str_list += ['pad : ' + str(self.pad)]
+            except ValueError:
+                str_list += ['pad : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def operation(self):
         return CUstreamBatchMemOpType(self._ptr[0].operation)
     @operation.setter
     def operation(self, operation not None : CUstreamBatchMemOpType):
-        pass
         self._ptr[0].operation = operation.value
     @property
     def waitValue(self):
         return self._waitValue
     @waitValue.setter
     def waitValue(self, waitValue not None : CUstreamMemOpWaitValueParams_st):
-        pass
-        for _attr in dir(waitValue):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._waitValue, _attr, getattr(waitValue, _attr))
+        string.memcpy(&self._ptr[0].waitValue, <cydriver.CUstreamMemOpWaitValueParams_st*><void_ptr>waitValue.getPtr(), sizeof(self._ptr[0].waitValue))
     @property
     def writeValue(self):
         return self._writeValue
     @writeValue.setter
     def writeValue(self, writeValue not None : CUstreamMemOpWriteValueParams_st):
-        pass
-        for _attr in dir(writeValue):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._writeValue, _attr, getattr(writeValue, _attr))
+        string.memcpy(&self._ptr[0].writeValue, <cydriver.CUstreamMemOpWriteValueParams_st*><void_ptr>writeValue.getPtr(), sizeof(self._ptr[0].writeValue))
     @property
     def flushRemoteWrites(self):
         return self._flushRemoteWrites
     @flushRemoteWrites.setter
     def flushRemoteWrites(self, flushRemoteWrites not None : CUstreamMemOpFlushRemoteWritesParams_st):
-        pass
-        for _attr in dir(flushRemoteWrites):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._flushRemoteWrites, _attr, getattr(flushRemoteWrites, _attr))
+        string.memcpy(&self._ptr[0].flushRemoteWrites, <cydriver.CUstreamMemOpFlushRemoteWritesParams_st*><void_ptr>flushRemoteWrites.getPtr(), sizeof(self._ptr[0].flushRemoteWrites))
     @property
     def memoryBarrier(self):
         return self._memoryBarrier
     @memoryBarrier.setter
     def memoryBarrier(self, memoryBarrier not None : CUstreamMemOpMemoryBarrierParams_st):
-        pass
-        for _attr in dir(memoryBarrier):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._memoryBarrier, _attr, getattr(memoryBarrier, _attr))
+        string.memcpy(&self._ptr[0].memoryBarrier, <cydriver.CUstreamMemOpMemoryBarrierParams_st*><void_ptr>memoryBarrier.getPtr(), sizeof(self._ptr[0].memoryBarrier))
     @property
     def pad(self):
         return [cuuint64_t(init_value=_pad) for _pad in self._ptr[0].pad]
     @pad.setter
     def pad(self, pad):
-        pass
         self._ptr[0].pad = pad
+
 {{endif}}
-{{if 'CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
     """
-
     Attributes
     ----------
     ctx : CUcontext
@@ -5996,7 +6236,7 @@ cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._ctx = CUcontext(_ptr=<void_ptr>&self._ptr[0].ctx)
     def __dealloc__(self):
@@ -6007,39 +6247,49 @@ cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['ctx : ' + str(self.ctx)]
-            str_list += ['count : ' + str(self.count)]
-            str_list += ['paramArray : ' + str(self.paramArray)]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['ctx : ' + str(self.ctx)]
+            except ValueError:
+                str_list += ['ctx : <ValueError>']
+            try:
+                str_list += ['count : ' + str(self.count)]
+            except ValueError:
+                str_list += ['count : <ValueError>']
+            try:
+                str_list += ['paramArray : ' + str(self.paramArray)]
+            except ValueError:
+                str_list += ['paramArray : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def ctx(self):
         return self._ctx
     @ctx.setter
     def ctx(self, ctx):
-        cdef ccuda.CUcontext cctx
+        cdef cydriver.CUcontext cyctx
         if ctx is None:
-            cctx = <ccuda.CUcontext><void_ptr>0
-        elif isinstance(ctx, (CUcontext)):
+            cyctx = <cydriver.CUcontext><void_ptr>0
+        elif isinstance(ctx, (CUcontext,)):
             pctx = int(ctx)
-            cctx = <ccuda.CUcontext><void_ptr>pctx
+            cyctx = <cydriver.CUcontext><void_ptr>pctx
         else:
             pctx = int(CUcontext(ctx))
-            cctx = <ccuda.CUcontext><void_ptr>pctx
-        self._ctx._ptr[0] = cctx
+            cyctx = <cydriver.CUcontext><void_ptr>pctx
+        self._ctx._ptr[0] = cyctx
     @property
     def count(self):
         return self._ptr[0].count
     @count.setter
     def count(self, unsigned int count):
-        pass
         self._ptr[0].count = count
     @property
     def paramArray(self):
-        arrs = [<void_ptr>self._ptr[0].paramArray + x*sizeof(ccuda.CUstreamBatchMemOpParams) for x in range(self._paramArray_length)]
+        arrs = [<void_ptr>self._ptr[0].paramArray + x*sizeof(cydriver.CUstreamBatchMemOpParams) for x in range(self._paramArray_length)]
         return [CUstreamBatchMemOpParams(_ptr=arr) for arr in arrs]
     @paramArray.setter
     def paramArray(self, val):
@@ -6050,22 +6300,22 @@ cdef class CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
         else:
             if self._paramArray_length != <size_t>len(val):
                 free(self._paramArray)
-                self._paramArray = <ccuda.CUstreamBatchMemOpParams*> calloc(len(val), sizeof(ccuda.CUstreamBatchMemOpParams))
+                self._paramArray = <cydriver.CUstreamBatchMemOpParams*> calloc(len(val), sizeof(cydriver.CUstreamBatchMemOpParams))
                 if self._paramArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUstreamBatchMemOpParams)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUstreamBatchMemOpParams)))
                 self._paramArray_length = <size_t>len(val)
                 self._ptr[0].paramArray = self._paramArray
             for idx in range(len(val)):
-                memcpy(&self._paramArray[idx], (<CUstreamBatchMemOpParams>val[idx])._ptr, sizeof(ccuda.CUstreamBatchMemOpParams))
+                string.memcpy(&self._paramArray[idx], (<CUstreamBatchMemOpParams>val[idx])._ptr, sizeof(cydriver.CUstreamBatchMemOpParams))
+
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
 {{endif}}
-{{if 'CUdevprop_st' in found_types}}
+{{if 'struct CUdevprop_st' in found_types}}
 
 cdef class CUdevprop_st:
     """
@@ -6104,7 +6354,7 @@ cdef class CUdevprop_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUdevprop_st *>_ptr
+            self._ptr = <cydriver.CUdevprop_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -6114,92 +6364,111 @@ cdef class CUdevprop_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]
-            str_list += ['maxThreadsDim : ' + str(self.maxThreadsDim)]
-            str_list += ['maxGridSize : ' + str(self.maxGridSize)]
-            str_list += ['sharedMemPerBlock : ' + str(self.sharedMemPerBlock)]
-            str_list += ['totalConstantMemory : ' + str(self.totalConstantMemory)]
-            str_list += ['SIMDWidth : ' + str(self.SIMDWidth)]
-            str_list += ['memPitch : ' + str(self.memPitch)]
-            str_list += ['regsPerBlock : ' + str(self.regsPerBlock)]
-            str_list += ['clockRate : ' + str(self.clockRate)]
-            str_list += ['textureAlign : ' + str(self.textureAlign)]
+            try:
+                str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]
+            except ValueError:
+                str_list += ['maxThreadsPerBlock : <ValueError>']
+            try:
+                str_list += ['maxThreadsDim : ' + str(self.maxThreadsDim)]
+            except ValueError:
+                str_list += ['maxThreadsDim : <ValueError>']
+            try:
+                str_list += ['maxGridSize : ' + str(self.maxGridSize)]
+            except ValueError:
+                str_list += ['maxGridSize : <ValueError>']
+            try:
+                str_list += ['sharedMemPerBlock : ' + str(self.sharedMemPerBlock)]
+            except ValueError:
+                str_list += ['sharedMemPerBlock : <ValueError>']
+            try:
+                str_list += ['totalConstantMemory : ' + str(self.totalConstantMemory)]
+            except ValueError:
+                str_list += ['totalConstantMemory : <ValueError>']
+            try:
+                str_list += ['SIMDWidth : ' + str(self.SIMDWidth)]
+            except ValueError:
+                str_list += ['SIMDWidth : <ValueError>']
+            try:
+                str_list += ['memPitch : ' + str(self.memPitch)]
+            except ValueError:
+                str_list += ['memPitch : <ValueError>']
+            try:
+                str_list += ['regsPerBlock : ' + str(self.regsPerBlock)]
+            except ValueError:
+                str_list += ['regsPerBlock : <ValueError>']
+            try:
+                str_list += ['clockRate : ' + str(self.clockRate)]
+            except ValueError:
+                str_list += ['clockRate : <ValueError>']
+            try:
+                str_list += ['textureAlign : ' + str(self.textureAlign)]
+            except ValueError:
+                str_list += ['textureAlign : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def maxThreadsPerBlock(self):
         return self._ptr[0].maxThreadsPerBlock
     @maxThreadsPerBlock.setter
     def maxThreadsPerBlock(self, int maxThreadsPerBlock):
-        pass
         self._ptr[0].maxThreadsPerBlock = maxThreadsPerBlock
     @property
     def maxThreadsDim(self):
         return self._ptr[0].maxThreadsDim
     @maxThreadsDim.setter
     def maxThreadsDim(self, maxThreadsDim):
-        pass
         self._ptr[0].maxThreadsDim = maxThreadsDim
     @property
     def maxGridSize(self):
         return self._ptr[0].maxGridSize
     @maxGridSize.setter
     def maxGridSize(self, maxGridSize):
-        pass
         self._ptr[0].maxGridSize = maxGridSize
     @property
     def sharedMemPerBlock(self):
         return self._ptr[0].sharedMemPerBlock
     @sharedMemPerBlock.setter
     def sharedMemPerBlock(self, int sharedMemPerBlock):
-        pass
         self._ptr[0].sharedMemPerBlock = sharedMemPerBlock
     @property
     def totalConstantMemory(self):
         return self._ptr[0].totalConstantMemory
     @totalConstantMemory.setter
     def totalConstantMemory(self, int totalConstantMemory):
-        pass
         self._ptr[0].totalConstantMemory = totalConstantMemory
     @property
     def SIMDWidth(self):
         return self._ptr[0].SIMDWidth
     @SIMDWidth.setter
     def SIMDWidth(self, int SIMDWidth):
-        pass
         self._ptr[0].SIMDWidth = SIMDWidth
     @property
     def memPitch(self):
         return self._ptr[0].memPitch
     @memPitch.setter
     def memPitch(self, int memPitch):
-        pass
         self._ptr[0].memPitch = memPitch
     @property
     def regsPerBlock(self):
         return self._ptr[0].regsPerBlock
     @regsPerBlock.setter
     def regsPerBlock(self, int regsPerBlock):
-        pass
         self._ptr[0].regsPerBlock = regsPerBlock
     @property
     def clockRate(self):
         return self._ptr[0].clockRate
     @clockRate.setter
     def clockRate(self, int clockRate):
-        pass
         self._ptr[0].clockRate = clockRate
     @property
     def textureAlign(self):
         return self._ptr[0].textureAlign
     @textureAlign.setter
     def textureAlign(self, int textureAlign):
-        pass
         self._ptr[0].textureAlign = textureAlign
 {{endif}}
-{{if 'CUaccessPolicyWindow_st' in found_types}}
+{{if 'struct CUaccessPolicyWindow_st' in found_types}}
 
 cdef class CUaccessPolicyWindow_st:
     """
@@ -6240,7 +6509,7 @@ cdef class CUaccessPolicyWindow_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUaccessPolicyWindow_st *>_ptr
+            self._ptr = <cydriver.CUaccessPolicyWindow_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -6250,52 +6519,62 @@ cdef class CUaccessPolicyWindow_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['base_ptr : ' + hex(self.base_ptr)]
-            str_list += ['num_bytes : ' + str(self.num_bytes)]
-            str_list += ['hitRatio : ' + str(self.hitRatio)]
-            str_list += ['hitProp : ' + str(self.hitProp)]
-            str_list += ['missProp : ' + str(self.missProp)]
+            try:
+                str_list += ['base_ptr : ' + hex(self.base_ptr)]
+            except ValueError:
+                str_list += ['base_ptr : <ValueError>']
+            try:
+                str_list += ['num_bytes : ' + str(self.num_bytes)]
+            except ValueError:
+                str_list += ['num_bytes : <ValueError>']
+            try:
+                str_list += ['hitRatio : ' + str(self.hitRatio)]
+            except ValueError:
+                str_list += ['hitRatio : <ValueError>']
+            try:
+                str_list += ['hitProp : ' + str(self.hitProp)]
+            except ValueError:
+                str_list += ['hitProp : <ValueError>']
+            try:
+                str_list += ['missProp : ' + str(self.missProp)]
+            except ValueError:
+                str_list += ['missProp : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def base_ptr(self):
         return <void_ptr>self._ptr[0].base_ptr
     @base_ptr.setter
     def base_ptr(self, base_ptr):
-        _cbase_ptr = utils.HelperInputVoidPtr(base_ptr)
-        self._ptr[0].base_ptr = <void*><void_ptr>_cbase_ptr.cptr
+        _cybase_ptr = utils.HelperInputVoidPtr(base_ptr)
+        self._ptr[0].base_ptr = <void*><void_ptr>_cybase_ptr.cptr
     @property
     def num_bytes(self):
         return self._ptr[0].num_bytes
     @num_bytes.setter
     def num_bytes(self, size_t num_bytes):
-        pass
         self._ptr[0].num_bytes = num_bytes
     @property
     def hitRatio(self):
         return self._ptr[0].hitRatio
     @hitRatio.setter
     def hitRatio(self, float hitRatio):
-        pass
         self._ptr[0].hitRatio = hitRatio
     @property
     def hitProp(self):
         return CUaccessProperty(self._ptr[0].hitProp)
     @hitProp.setter
     def hitProp(self, hitProp not None : CUaccessProperty):
-        pass
         self._ptr[0].hitProp = hitProp.value
     @property
     def missProp(self):
         return CUaccessProperty(self._ptr[0].missProp)
     @missProp.setter
     def missProp(self, missProp not None : CUaccessProperty):
-        pass
         self._ptr[0].missProp = missProp.value
 {{endif}}
-{{if 'CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_KERNEL_NODE_PARAMS_st:
     """
@@ -6334,7 +6613,7 @@ cdef class CUDA_KERNEL_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_KERNEL_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_KERNEL_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._func = CUfunction(_ptr=<void_ptr>&self._ptr[0].func)
     def __dealloc__(self):
@@ -6344,91 +6623,113 @@ cdef class CUDA_KERNEL_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['func : ' + str(self.func)]
-            str_list += ['gridDimX : ' + str(self.gridDimX)]
-            str_list += ['gridDimY : ' + str(self.gridDimY)]
-            str_list += ['gridDimZ : ' + str(self.gridDimZ)]
-            str_list += ['blockDimX : ' + str(self.blockDimX)]
-            str_list += ['blockDimY : ' + str(self.blockDimY)]
-            str_list += ['blockDimZ : ' + str(self.blockDimZ)]
-            str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
-            str_list += ['kernelParams : ' + str(self.kernelParams)]
-            str_list += ['extra : ' + str(self.extra)]
+            try:
+                str_list += ['func : ' + str(self.func)]
+            except ValueError:
+                str_list += ['func : <ValueError>']
+            try:
+                str_list += ['gridDimX : ' + str(self.gridDimX)]
+            except ValueError:
+                str_list += ['gridDimX : <ValueError>']
+            try:
+                str_list += ['gridDimY : ' + str(self.gridDimY)]
+            except ValueError:
+                str_list += ['gridDimY : <ValueError>']
+            try:
+                str_list += ['gridDimZ : ' + str(self.gridDimZ)]
+            except ValueError:
+                str_list += ['gridDimZ : <ValueError>']
+            try:
+                str_list += ['blockDimX : ' + str(self.blockDimX)]
+            except ValueError:
+                str_list += ['blockDimX : <ValueError>']
+            try:
+                str_list += ['blockDimY : ' + str(self.blockDimY)]
+            except ValueError:
+                str_list += ['blockDimY : <ValueError>']
+            try:
+                str_list += ['blockDimZ : ' + str(self.blockDimZ)]
+            except ValueError:
+                str_list += ['blockDimZ : <ValueError>']
+            try:
+                str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
+            except ValueError:
+                str_list += ['sharedMemBytes : <ValueError>']
+            try:
+                str_list += ['kernelParams : ' + str(self.kernelParams)]
+            except ValueError:
+                str_list += ['kernelParams : <ValueError>']
+            try:
+                str_list += ['extra : ' + str(self.extra)]
+            except ValueError:
+                str_list += ['extra : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def func(self):
         return self._func
     @func.setter
     def func(self, func):
-        cdef ccuda.CUfunction cfunc
+        cdef cydriver.CUfunction cyfunc
         if func is None:
-            cfunc = <ccuda.CUfunction><void_ptr>0
-        elif isinstance(func, (CUfunction)):
+            cyfunc = <cydriver.CUfunction><void_ptr>0
+        elif isinstance(func, (CUfunction,)):
             pfunc = int(func)
-            cfunc = <ccuda.CUfunction><void_ptr>pfunc
+            cyfunc = <cydriver.CUfunction><void_ptr>pfunc
         else:
             pfunc = int(CUfunction(func))
-            cfunc = <ccuda.CUfunction><void_ptr>pfunc
-        self._func._ptr[0] = cfunc
+            cyfunc = <cydriver.CUfunction><void_ptr>pfunc
+        self._func._ptr[0] = cyfunc
     @property
     def gridDimX(self):
         return self._ptr[0].gridDimX
     @gridDimX.setter
     def gridDimX(self, unsigned int gridDimX):
-        pass
         self._ptr[0].gridDimX = gridDimX
     @property
     def gridDimY(self):
         return self._ptr[0].gridDimY
     @gridDimY.setter
     def gridDimY(self, unsigned int gridDimY):
-        pass
         self._ptr[0].gridDimY = gridDimY
     @property
     def gridDimZ(self):
         return self._ptr[0].gridDimZ
     @gridDimZ.setter
     def gridDimZ(self, unsigned int gridDimZ):
-        pass
         self._ptr[0].gridDimZ = gridDimZ
     @property
     def blockDimX(self):
         return self._ptr[0].blockDimX
     @blockDimX.setter
     def blockDimX(self, unsigned int blockDimX):
-        pass
         self._ptr[0].blockDimX = blockDimX
     @property
     def blockDimY(self):
         return self._ptr[0].blockDimY
     @blockDimY.setter
     def blockDimY(self, unsigned int blockDimY):
-        pass
         self._ptr[0].blockDimY = blockDimY
     @property
     def blockDimZ(self):
         return self._ptr[0].blockDimZ
     @blockDimZ.setter
     def blockDimZ(self, unsigned int blockDimZ):
-        pass
         self._ptr[0].blockDimZ = blockDimZ
     @property
     def sharedMemBytes(self):
         return self._ptr[0].sharedMemBytes
     @sharedMemBytes.setter
     def sharedMemBytes(self, unsigned int sharedMemBytes):
-        pass
         self._ptr[0].sharedMemBytes = sharedMemBytes
     @property
     def kernelParams(self):
         return <void_ptr>self._ptr[0].kernelParams
     @kernelParams.setter
     def kernelParams(self, kernelParams):
-        self._ckernelParams = utils.HelperKernelParams(kernelParams)
-        self._ptr[0].kernelParams = <void**><void_ptr>self._ckernelParams.ckernelParams
+        self._cykernelParams = utils.HelperKernelParams(kernelParams)
+        self._ptr[0].kernelParams = <void**><void_ptr>self._cykernelParams.ckernelParams
     @property
     def extra(self):
         return <void_ptr>self._ptr[0].extra
@@ -6436,7 +6737,7 @@ cdef class CUDA_KERNEL_NODE_PARAMS_st:
     def extra(self, void_ptr extra):
         self._ptr[0].extra = <void**>extra
 {{endif}}
-{{if 'CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_MEMSET_NODE_PARAMS_st:
     """
@@ -6467,7 +6768,7 @@ cdef class CUDA_MEMSET_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_MEMSET_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_MEMSET_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._dst = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].dst)
     def __dealloc__(self):
@@ -6477,68 +6778,81 @@ cdef class CUDA_MEMSET_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['dst : ' + str(self.dst)]
-            str_list += ['pitch : ' + str(self.pitch)]
-            str_list += ['value : ' + str(self.value)]
-            str_list += ['elementSize : ' + str(self.elementSize)]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
+            try:
+                str_list += ['dst : ' + str(self.dst)]
+            except ValueError:
+                str_list += ['dst : <ValueError>']
+            try:
+                str_list += ['pitch : ' + str(self.pitch)]
+            except ValueError:
+                str_list += ['pitch : <ValueError>']
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
+            try:
+                str_list += ['elementSize : ' + str(self.elementSize)]
+            except ValueError:
+                str_list += ['elementSize : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def dst(self):
         return self._dst
     @dst.setter
     def dst(self, dst):
-        cdef ccuda.CUdeviceptr cdst
+        cdef cydriver.CUdeviceptr cydst
         if dst is None:
-            cdst = <ccuda.CUdeviceptr><void_ptr>0
+            cydst = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(dst, (CUdeviceptr)):
             pdst = int(dst)
-            cdst = <ccuda.CUdeviceptr><void_ptr>pdst
+            cydst = <cydriver.CUdeviceptr><void_ptr>pdst
         else:
             pdst = int(CUdeviceptr(dst))
-            cdst = <ccuda.CUdeviceptr><void_ptr>pdst
-        self._dst._ptr[0] = cdst
+            cydst = <cydriver.CUdeviceptr><void_ptr>pdst
+        self._dst._ptr[0] = cydst
+
     @property
     def pitch(self):
         return self._ptr[0].pitch
     @pitch.setter
     def pitch(self, size_t pitch):
-        pass
         self._ptr[0].pitch = pitch
     @property
     def value(self):
         return self._ptr[0].value
     @value.setter
     def value(self, unsigned int value):
-        pass
         self._ptr[0].value = value
     @property
     def elementSize(self):
         return self._ptr[0].elementSize
     @elementSize.setter
     def elementSize(self, unsigned int elementSize):
-        pass
         self._ptr[0].elementSize = elementSize
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].height = height
 {{endif}}
-{{if 'CUDA_HOST_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_HOST_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_HOST_NODE_PARAMS_st:
     """
@@ -6561,7 +6875,7 @@ cdef class CUDA_HOST_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_HOST_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_HOST_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._fn = CUhostFn(_ptr=<void_ptr>&self._ptr[0].fn)
     def __dealloc__(self):
@@ -6571,40 +6885,44 @@ cdef class CUDA_HOST_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fn : ' + str(self.fn)]
-            str_list += ['userData : ' + hex(self.userData)]
+            try:
+                str_list += ['fn : ' + str(self.fn)]
+            except ValueError:
+                str_list += ['fn : <ValueError>']
+            try:
+                str_list += ['userData : ' + hex(self.userData)]
+            except ValueError:
+                str_list += ['userData : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fn(self):
         return self._fn
     @fn.setter
     def fn(self, fn):
-        cdef ccuda.CUhostFn cfn
+        cdef cydriver.CUhostFn cyfn
         if fn is None:
-            cfn = <ccuda.CUhostFn><void_ptr>0
+            cyfn = <cydriver.CUhostFn><void_ptr>0
         elif isinstance(fn, (CUhostFn)):
             pfn = int(fn)
-            cfn = <ccuda.CUhostFn><void_ptr>pfn
+            cyfn = <cydriver.CUhostFn><void_ptr>pfn
         else:
             pfn = int(CUhostFn(fn))
-            cfn = <ccuda.CUhostFn><void_ptr>pfn
-        self._fn._ptr[0] = cfn
+            cyfn = <cydriver.CUhostFn><void_ptr>pfn
+        self._fn._ptr[0] = cyfn
     @property
     def userData(self):
         return <void_ptr>self._ptr[0].userData
     @userData.setter
     def userData(self, userData):
-        _cuserData = utils.HelperInputVoidPtr(userData)
-        self._ptr[0].userData = <void*><void_ptr>_cuserData.cptr
+        _cyuserData = utils.HelperInputVoidPtr(userData)
+        self._ptr[0].userData = <void*><void_ptr>_cyuserData.cptr
 {{endif}}
-{{if 'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s' in found_types}}
+{{if 'union CUlaunchAttributeValue_union' in found_types}}
 
-cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s:
+cdef class anon_struct0:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -6621,48 +6939,55 @@ cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUlaunchAttributeValue_union *>_ptr
+        self._ptr = <cydriver.CUlaunchAttributeValue_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].clusterDim
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['x : ' + str(self.x)]
-            str_list += ['y : ' + str(self.y)]
-            str_list += ['z : ' + str(self.z)]
+            try:
+                str_list += ['x : ' + str(self.x)]
+            except ValueError:
+                str_list += ['x : <ValueError>']
+            try:
+                str_list += ['y : ' + str(self.y)]
+            except ValueError:
+                str_list += ['y : <ValueError>']
+            try:
+                str_list += ['z : ' + str(self.z)]
+            except ValueError:
+                str_list += ['z : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def x(self):
         return self._ptr[0].clusterDim.x
     @x.setter
     def x(self, unsigned int x):
-        pass
         self._ptr[0].clusterDim.x = x
     @property
     def y(self):
         return self._ptr[0].clusterDim.y
     @y.setter
     def y(self, unsigned int y):
-        pass
         self._ptr[0].clusterDim.y = y
     @property
     def z(self):
         return self._ptr[0].clusterDim.z
     @z.setter
     def z(self, unsigned int z):
-        pass
         self._ptr[0].clusterDim.z = z
 {{endif}}
-{{if 'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s' in found_types}}
+{{if 'union CUlaunchAttributeValue_union' in found_types}}
 
-cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s:
+cdef class anon_struct1:
     """
-
     Attributes
     ----------
     event : CUevent
@@ -6679,56 +7004,64 @@ cdef class _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUlaunchAttributeValue_union *>_ptr
+        self._ptr = <cydriver.CUlaunchAttributeValue_union *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._event = CUevent(_ptr=<void_ptr>&self._ptr[0].programmaticEvent.event)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].programmaticEvent
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['event : ' + str(self.event)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['triggerAtBlockStart : ' + str(self.triggerAtBlockStart)]
+            try:
+                str_list += ['event : ' + str(self.event)]
+            except ValueError:
+                str_list += ['event : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['triggerAtBlockStart : ' + str(self.triggerAtBlockStart)]
+            except ValueError:
+                str_list += ['triggerAtBlockStart : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def event(self):
         return self._event
     @event.setter
     def event(self, event):
-        cdef ccuda.CUevent cevent
+        cdef cydriver.CUevent cyevent
         if event is None:
-            cevent = <ccuda.CUevent><void_ptr>0
-        elif isinstance(event, (CUevent)):
+            cyevent = <cydriver.CUevent><void_ptr>0
+        elif isinstance(event, (CUevent,)):
             pevent = int(event)
-            cevent = <ccuda.CUevent><void_ptr>pevent
+            cyevent = <cydriver.CUevent><void_ptr>pevent
         else:
             pevent = int(CUevent(event))
-            cevent = <ccuda.CUevent><void_ptr>pevent
-        self._event._ptr[0] = cevent
+            cyevent = <cydriver.CUevent><void_ptr>pevent
+        self._event._ptr[0] = cyevent
     @property
     def flags(self):
         return self._ptr[0].programmaticEvent.flags
     @flags.setter
     def flags(self, int flags):
-        pass
         self._ptr[0].programmaticEvent.flags = flags
     @property
     def triggerAtBlockStart(self):
         return self._ptr[0].programmaticEvent.triggerAtBlockStart
     @triggerAtBlockStart.setter
     def triggerAtBlockStart(self, int triggerAtBlockStart):
-        pass
         self._ptr[0].programmaticEvent.triggerAtBlockStart = triggerAtBlockStart
 {{endif}}
 {{if 'union CUlaunchAttributeValue_union' in found_types}}
 
 cdef class CUlaunchAttributeValue_union:
     """
-
     Attributes
     ----------
     pad : bytes
@@ -6739,13 +7072,13 @@ cdef class CUlaunchAttributeValue_union:
 
     syncPolicy : CUsynchronizationPolicy
 
-    clusterDim : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s
+    clusterDim : anon_struct0
 
     clusterSchedulingPolicyPreference : CUclusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s
+    programmaticEvent : anon_struct1
 
     priority : int
 
@@ -6760,11 +7093,11 @@ cdef class CUlaunchAttributeValue_union:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUlaunchAttributeValue_union *>_ptr
+            self._ptr = <cydriver.CUlaunchAttributeValue_union *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        {{if 'accessPolicyWindow' in found_unions['CUlaunchAttributeValue_union']['members']}}self._accessPolicyWindow = CUaccessPolicyWindow(_ptr=<void_ptr>&self._ptr[0].accessPolicyWindow){{endif}}
-        {{if 'clusterDim' in found_unions['CUlaunchAttributeValue_union']['members']}}self._clusterDim = _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s(_ptr=<void_ptr>self._ptr){{endif}}
-        {{if 'programmaticEvent' in found_unions['CUlaunchAttributeValue_union']['members']}}self._programmaticEvent = _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s(_ptr=<void_ptr>self._ptr){{endif}}
+        self._accessPolicyWindow = CUaccessPolicyWindow(_ptr=<void_ptr>&self._ptr[0].accessPolicyWindow)
+        self._clusterDim = anon_struct0(_ptr=<void_ptr>self._ptr)
+        self._programmaticEvent = anon_struct1(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -6772,19 +7105,45 @@ cdef class CUlaunchAttributeValue_union:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            {{if 'pad' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['pad : ' + str(self.pad)]{{endif}}
-            {{if 'accessPolicyWindow' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['accessPolicyWindow :\n' + '\n'.join(['    ' + line for line in str(self.accessPolicyWindow).splitlines()])]{{endif}}
-            {{if 'cooperative' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['cooperative : ' + str(self.cooperative)]{{endif}}
-            {{if 'syncPolicy' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['syncPolicy : ' + str(self.syncPolicy)]{{endif}}
-            {{if 'clusterDim' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['clusterDim :\n' + '\n'.join(['    ' + line for line in str(self.clusterDim).splitlines()])]{{endif}}
-            {{if 'clusterSchedulingPolicyPreference' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)]{{endif}}
-            {{if 'programmaticStreamSerializationAllowed' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['programmaticStreamSerializationAllowed : ' + str(self.programmaticStreamSerializationAllowed)]{{endif}}
-            {{if 'programmaticEvent' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['programmaticEvent :\n' + '\n'.join(['    ' + line for line in str(self.programmaticEvent).splitlines()])]{{endif}}
-            {{if 'priority' in found_unions['CUlaunchAttributeValue_union']['members']}}str_list += ['priority : ' + str(self.priority)]{{endif}}
+            try:
+                str_list += ['pad : ' + str(self.pad)]
+            except ValueError:
+                str_list += ['pad : <ValueError>']
+            try:
+                str_list += ['accessPolicyWindow :\n' + '\n'.join(['    ' + line for line in str(self.accessPolicyWindow).splitlines()])]
+            except ValueError:
+                str_list += ['accessPolicyWindow : <ValueError>']
+            try:
+                str_list += ['cooperative : ' + str(self.cooperative)]
+            except ValueError:
+                str_list += ['cooperative : <ValueError>']
+            try:
+                str_list += ['syncPolicy : ' + str(self.syncPolicy)]
+            except ValueError:
+                str_list += ['syncPolicy : <ValueError>']
+            try:
+                str_list += ['clusterDim :\n' + '\n'.join(['    ' + line for line in str(self.clusterDim).splitlines()])]
+            except ValueError:
+                str_list += ['clusterDim : <ValueError>']
+            try:
+                str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)]
+            except ValueError:
+                str_list += ['clusterSchedulingPolicyPreference : <ValueError>']
+            try:
+                str_list += ['programmaticStreamSerializationAllowed : ' + str(self.programmaticStreamSerializationAllowed)]
+            except ValueError:
+                str_list += ['programmaticStreamSerializationAllowed : <ValueError>']
+            try:
+                str_list += ['programmaticEvent :\n' + '\n'.join(['    ' + line for line in str(self.programmaticEvent).splitlines()])]
+            except ValueError:
+                str_list += ['programmaticEvent : <ValueError>']
+            try:
+                str_list += ['priority : ' + str(self.priority)]
+            except ValueError:
+                str_list += ['priority : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-    {{if 'pad' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def pad(self):
         return PyBytes_FromStringAndSize(self._ptr[0].pad, 64)
@@ -6802,89 +7161,59 @@ cdef class CUlaunchAttributeValue_union:
                 if b > 127 and b < 256:
                     b = b - 256
                 self._ptr[0].pad[i] = b
-    {{endif}}
-    {{if 'accessPolicyWindow' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def accessPolicyWindow(self):
         return self._accessPolicyWindow
     @accessPolicyWindow.setter
     def accessPolicyWindow(self, accessPolicyWindow not None : CUaccessPolicyWindow):
-        for _attr in dir(accessPolicyWindow):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._accessPolicyWindow, _attr, getattr(accessPolicyWindow, _attr))
-    {{endif}}
-    {{if 'cooperative' in found_unions['CUlaunchAttributeValue_union']['members']}}
+        string.memcpy(&self._ptr[0].accessPolicyWindow, <cydriver.CUaccessPolicyWindow*><void_ptr>accessPolicyWindow.getPtr(), sizeof(self._ptr[0].accessPolicyWindow))
     @property
     def cooperative(self):
         return self._ptr[0].cooperative
     @cooperative.setter
     def cooperative(self, int cooperative):
         self._ptr[0].cooperative = cooperative
-    {{endif}}
-    {{if 'syncPolicy' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def syncPolicy(self):
         return CUsynchronizationPolicy(self._ptr[0].syncPolicy)
     @syncPolicy.setter
     def syncPolicy(self, syncPolicy not None : CUsynchronizationPolicy):
         self._ptr[0].syncPolicy = syncPolicy.value
-    {{endif}}
-    {{if 'clusterDim' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def clusterDim(self):
         return self._clusterDim
     @clusterDim.setter
-    def clusterDim(self, clusterDim not None : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s):
-        for _attr in dir(clusterDim):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._clusterDim, _attr, getattr(clusterDim, _attr))
-    {{endif}}
-    {{if 'clusterSchedulingPolicyPreference' in found_unions['CUlaunchAttributeValue_union']['members']}}
+    def clusterDim(self, clusterDim not None : anon_struct0):
+        string.memcpy(&self._ptr[0].clusterDim, <cydriver.anon_struct0*><void_ptr>clusterDim.getPtr(), sizeof(self._ptr[0].clusterDim))
     @property
     def clusterSchedulingPolicyPreference(self):
         return CUclusterSchedulingPolicy(self._ptr[0].clusterSchedulingPolicyPreference)
     @clusterSchedulingPolicyPreference.setter
     def clusterSchedulingPolicyPreference(self, clusterSchedulingPolicyPreference not None : CUclusterSchedulingPolicy):
         self._ptr[0].clusterSchedulingPolicyPreference = clusterSchedulingPolicyPreference.value
-    {{endif}}
-    {{if 'programmaticStreamSerializationAllowed' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def programmaticStreamSerializationAllowed(self):
         return self._ptr[0].programmaticStreamSerializationAllowed
     @programmaticStreamSerializationAllowed.setter
     def programmaticStreamSerializationAllowed(self, int programmaticStreamSerializationAllowed):
         self._ptr[0].programmaticStreamSerializationAllowed = programmaticStreamSerializationAllowed
-    {{endif}}
-    {{if 'programmaticEvent' in found_unions['CUlaunchAttributeValue_union']['members']}}
     @property
     def programmaticEvent(self):
         return self._programmaticEvent
     @programmaticEvent.setter
-    def programmaticEvent(self, programmaticEvent not None : _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s):
-        for _attr in dir(programmaticEvent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._programmaticEvent, _attr, getattr(programmaticEvent, _attr))
-    {{endif}}
-    {{if 'priority' in found_unions['CUlaunchAttributeValue_union']['members']}}
+    def programmaticEvent(self, programmaticEvent not None : anon_struct1):
+        string.memcpy(&self._ptr[0].programmaticEvent, <cydriver.anon_struct1*><void_ptr>programmaticEvent.getPtr(), sizeof(self._ptr[0].programmaticEvent))
     @property
     def priority(self):
         return self._ptr[0].priority
     @priority.setter
     def priority(self, int priority):
         self._ptr[0].priority = priority
-    {{endif}}
 {{endif}}
-{{if 'CUlaunchAttribute_st' in found_types}}
+{{if 'struct CUlaunchAttribute_st' in found_types}}
 
 cdef class CUlaunchAttribute_st:
     """
-
     Attributes
     ----------
     id : CUlaunchAttributeID
@@ -6902,7 +7231,7 @@ cdef class CUlaunchAttribute_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUlaunchAttribute_st *>_ptr
+            self._ptr = <cydriver.CUlaunchAttribute_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._value = CUlaunchAttributeValue(_ptr=<void_ptr>&self._ptr[0].value)
     def __dealloc__(self):
@@ -6912,36 +7241,34 @@ cdef class CUlaunchAttribute_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['id : ' + str(self.id)]
-            str_list += ['value :\n' + '\n'.join(['    ' + line for line in str(self.value).splitlines()])]
+            try:
+                str_list += ['id : ' + str(self.id)]
+            except ValueError:
+                str_list += ['id : <ValueError>']
+            try:
+                str_list += ['value :\n' + '\n'.join(['    ' + line for line in str(self.value).splitlines()])]
+            except ValueError:
+                str_list += ['value : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def id(self):
         return CUlaunchAttributeID(self._ptr[0].id)
     @id.setter
     def id(self, id not None : CUlaunchAttributeID):
-        pass
         self._ptr[0].id = id.value
     @property
     def value(self):
         return self._value
     @value.setter
     def value(self, value not None : CUlaunchAttributeValue):
-        pass
-        for _attr in dir(value):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._value, _attr, getattr(value, _attr))
+        string.memcpy(&self._ptr[0].value, <cydriver.CUlaunchAttributeValue*><void_ptr>value.getPtr(), sizeof(self._ptr[0].value))
 {{endif}}
-{{if 'CUlaunchConfig_st' in found_types}}
+{{if 'struct CUlaunchConfig_st' in found_types}}
 
 cdef class CUlaunchConfig_st:
     """
-
     Attributes
     ----------
     gridDimX : unsigned int
@@ -6975,7 +7302,7 @@ cdef class CUlaunchConfig_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUlaunchConfig_st *>_ptr
+            self._ptr = <cydriver.CUlaunchConfig_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._hStream = CUstream(_ptr=<void_ptr>&self._ptr[0].hStream)
     def __dealloc__(self):
@@ -6986,87 +7313,109 @@ cdef class CUlaunchConfig_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['gridDimX : ' + str(self.gridDimX)]
-            str_list += ['gridDimY : ' + str(self.gridDimY)]
-            str_list += ['gridDimZ : ' + str(self.gridDimZ)]
-            str_list += ['blockDimX : ' + str(self.blockDimX)]
-            str_list += ['blockDimY : ' + str(self.blockDimY)]
-            str_list += ['blockDimZ : ' + str(self.blockDimZ)]
-            str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
-            str_list += ['hStream : ' + str(self.hStream)]
-            str_list += ['attrs : ' + str(self.attrs)]
-            str_list += ['numAttrs : ' + str(self.numAttrs)]
+            try:
+                str_list += ['gridDimX : ' + str(self.gridDimX)]
+            except ValueError:
+                str_list += ['gridDimX : <ValueError>']
+            try:
+                str_list += ['gridDimY : ' + str(self.gridDimY)]
+            except ValueError:
+                str_list += ['gridDimY : <ValueError>']
+            try:
+                str_list += ['gridDimZ : ' + str(self.gridDimZ)]
+            except ValueError:
+                str_list += ['gridDimZ : <ValueError>']
+            try:
+                str_list += ['blockDimX : ' + str(self.blockDimX)]
+            except ValueError:
+                str_list += ['blockDimX : <ValueError>']
+            try:
+                str_list += ['blockDimY : ' + str(self.blockDimY)]
+            except ValueError:
+                str_list += ['blockDimY : <ValueError>']
+            try:
+                str_list += ['blockDimZ : ' + str(self.blockDimZ)]
+            except ValueError:
+                str_list += ['blockDimZ : <ValueError>']
+            try:
+                str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
+            except ValueError:
+                str_list += ['sharedMemBytes : <ValueError>']
+            try:
+                str_list += ['hStream : ' + str(self.hStream)]
+            except ValueError:
+                str_list += ['hStream : <ValueError>']
+            try:
+                str_list += ['attrs : ' + str(self.attrs)]
+            except ValueError:
+                str_list += ['attrs : <ValueError>']
+            try:
+                str_list += ['numAttrs : ' + str(self.numAttrs)]
+            except ValueError:
+                str_list += ['numAttrs : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def gridDimX(self):
         return self._ptr[0].gridDimX
     @gridDimX.setter
     def gridDimX(self, unsigned int gridDimX):
-        pass
         self._ptr[0].gridDimX = gridDimX
     @property
     def gridDimY(self):
         return self._ptr[0].gridDimY
     @gridDimY.setter
     def gridDimY(self, unsigned int gridDimY):
-        pass
         self._ptr[0].gridDimY = gridDimY
     @property
     def gridDimZ(self):
         return self._ptr[0].gridDimZ
     @gridDimZ.setter
     def gridDimZ(self, unsigned int gridDimZ):
-        pass
         self._ptr[0].gridDimZ = gridDimZ
     @property
     def blockDimX(self):
         return self._ptr[0].blockDimX
     @blockDimX.setter
     def blockDimX(self, unsigned int blockDimX):
-        pass
         self._ptr[0].blockDimX = blockDimX
     @property
     def blockDimY(self):
         return self._ptr[0].blockDimY
     @blockDimY.setter
     def blockDimY(self, unsigned int blockDimY):
-        pass
         self._ptr[0].blockDimY = blockDimY
     @property
     def blockDimZ(self):
         return self._ptr[0].blockDimZ
     @blockDimZ.setter
     def blockDimZ(self, unsigned int blockDimZ):
-        pass
         self._ptr[0].blockDimZ = blockDimZ
     @property
     def sharedMemBytes(self):
         return self._ptr[0].sharedMemBytes
     @sharedMemBytes.setter
     def sharedMemBytes(self, unsigned int sharedMemBytes):
-        pass
         self._ptr[0].sharedMemBytes = sharedMemBytes
     @property
     def hStream(self):
         return self._hStream
     @hStream.setter
     def hStream(self, hStream):
-        cdef ccuda.CUstream chStream
+        cdef cydriver.CUstream cyhStream
         if hStream is None:
-            chStream = <ccuda.CUstream><void_ptr>0
-        elif isinstance(hStream, (CUstream)):
+            cyhStream = <cydriver.CUstream><void_ptr>0
+        elif isinstance(hStream, (CUstream,)):
             phStream = int(hStream)
-            chStream = <ccuda.CUstream><void_ptr>phStream
+            cyhStream = <cydriver.CUstream><void_ptr>phStream
         else:
             phStream = int(CUstream(hStream))
-            chStream = <ccuda.CUstream><void_ptr>phStream
-        self._hStream._ptr[0] = chStream
+            cyhStream = <cydriver.CUstream><void_ptr>phStream
+        self._hStream._ptr[0] = cyhStream
     @property
     def attrs(self):
-        arrs = [<void_ptr>self._ptr[0].attrs + x*sizeof(ccuda.CUlaunchAttribute) for x in range(self._attrs_length)]
+        arrs = [<void_ptr>self._ptr[0].attrs + x*sizeof(cydriver.CUlaunchAttribute) for x in range(self._attrs_length)]
         return [CUlaunchAttribute(_ptr=arr) for arr in arrs]
     @attrs.setter
     def attrs(self, val):
@@ -7077,22 +7426,22 @@ cdef class CUlaunchConfig_st:
         else:
             if self._attrs_length != <size_t>len(val):
                 free(self._attrs)
-                self._attrs = <ccuda.CUlaunchAttribute*> calloc(len(val), sizeof(ccuda.CUlaunchAttribute))
+                self._attrs = <cydriver.CUlaunchAttribute*> calloc(len(val), sizeof(cydriver.CUlaunchAttribute))
                 if self._attrs is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUlaunchAttribute)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUlaunchAttribute)))
                 self._attrs_length = <size_t>len(val)
                 self._ptr[0].attrs = self._attrs
             for idx in range(len(val)):
-                memcpy(&self._attrs[idx], (<CUlaunchAttribute>val[idx])._ptr, sizeof(ccuda.CUlaunchAttribute))
+                string.memcpy(&self._attrs[idx], (<CUlaunchAttribute>val[idx])._ptr, sizeof(cydriver.CUlaunchAttribute))
+
     @property
     def numAttrs(self):
         return self._ptr[0].numAttrs
     @numAttrs.setter
     def numAttrs(self, unsigned int numAttrs):
-        pass
         self._ptr[0].numAttrs = numAttrs
 {{endif}}
-{{if 'CUexecAffinitySmCount_st' in found_types}}
+{{if 'struct CUexecAffinitySmCount_st' in found_types}}
 
 cdef class CUexecAffinitySmCount_st:
     """
@@ -7113,7 +7462,7 @@ cdef class CUexecAffinitySmCount_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUexecAffinitySmCount_st *>_ptr
+            self._ptr = <cydriver.CUexecAffinitySmCount_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -7123,24 +7472,24 @@ cdef class CUexecAffinitySmCount_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['val : ' + str(self.val)]
+            try:
+                str_list += ['val : ' + str(self.val)]
+            except ValueError:
+                str_list += ['val : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def val(self):
         return self._ptr[0].val
     @val.setter
     def val(self, unsigned int val):
-        pass
         self._ptr[0].val = val
 {{endif}}
-{{if 'CUexecAffinityParam_st' in found_types}}
+{{if 'struct CUexecAffinityParam_st' in found_types}}
 
-cdef class _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u:
+cdef class anon_union2:
     """
-
     Attributes
     ----------
     smCount : CUexecAffinitySmCount
@@ -7153,32 +7502,32 @@ cdef class _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUexecAffinityParam_st *>_ptr
+        self._ptr = <cydriver.CUexecAffinityParam_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._smCount = CUexecAffinitySmCount(_ptr=<void_ptr>&self._ptr[0].param.smCount)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].param
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['smCount :\n' + '\n'.join(['    ' + line for line in str(self.smCount).splitlines()])]
+            try:
+                str_list += ['smCount :\n' + '\n'.join(['    ' + line for line in str(self.smCount).splitlines()])]
+            except ValueError:
+                str_list += ['smCount : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def smCount(self):
         return self._smCount
     @smCount.setter
     def smCount(self, smCount not None : CUexecAffinitySmCount):
-        pass
-        for _attr in dir(smCount):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._smCount, _attr, getattr(smCount, _attr))
+        string.memcpy(&self._ptr[0].param.smCount, <cydriver.CUexecAffinitySmCount*><void_ptr>smCount.getPtr(), sizeof(self._ptr[0].param.smCount))
 {{endif}}
-{{if 'CUexecAffinityParam_st' in found_types}}
+{{if 'struct CUexecAffinityParam_st' in found_types}}
 
 cdef class CUexecAffinityParam_st:
     """
@@ -7188,7 +7537,7 @@ cdef class CUexecAffinityParam_st:
     ----------
     type : CUexecAffinityType
 
-    param : _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u
+    param : anon_union2
 
 
     Methods
@@ -7199,44 +7548,45 @@ cdef class CUexecAffinityParam_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUexecAffinityParam_st *>calloc(1, sizeof(cydriver.CUexecAffinityParam_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUexecAffinityParam_st *>_ptr
+            self._ptr = <cydriver.CUexecAffinityParam_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._param = _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u(_ptr=<void_ptr>self._ptr)
+        self._param = anon_union2(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['param :\n' + '\n'.join(['    ' + line for line in str(self.param).splitlines()])]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['param :\n' + '\n'.join(['    ' + line for line in str(self.param).splitlines()])]
+            except ValueError:
+                str_list += ['param : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return CUexecAffinityType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : CUexecAffinityType):
-        pass
         self._ptr[0].type = type.value
     @property
     def param(self):
         return self._param
     @param.setter
-    def param(self, param not None : _CUexecAffinityParam_v1_CUexecAffinityParam_v1_CUexecAffinityParam_st_param_u):
-        pass
-        for _attr in dir(param):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._param, _attr, getattr(param, _attr))
+    def param(self, param not None : anon_union2):
+        string.memcpy(&self._ptr[0].param, <cydriver.anon_union2*><void_ptr>param.getPtr(), sizeof(self._ptr[0].param))
 {{endif}}
-{{if 'CUDA_MEMCPY2D_st' in found_types}}
+{{if 'struct CUDA_MEMCPY2D_st' in found_types}}
 
 cdef class CUDA_MEMCPY2D_st:
     """
@@ -7287,7 +7637,7 @@ cdef class CUDA_MEMCPY2D_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_MEMCPY2D_st *>_ptr
+            self._ptr = <cydriver.CUDA_MEMCPY2D_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._srcDevice = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].srcDevice)
         self._srcArray = CUarray(_ptr=<void_ptr>&self._ptr[0].srcArray)
@@ -7300,172 +7650,211 @@ cdef class CUDA_MEMCPY2D_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
-            str_list += ['srcY : ' + str(self.srcY)]
-            str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
-            str_list += ['srcHost : ' + hex(self.srcHost)]
-            str_list += ['srcDevice : ' + str(self.srcDevice)]
-            str_list += ['srcArray : ' + str(self.srcArray)]
-            str_list += ['srcPitch : ' + str(self.srcPitch)]
-            str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
-            str_list += ['dstY : ' + str(self.dstY)]
-            str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
-            str_list += ['dstHost : ' + hex(self.dstHost)]
-            str_list += ['dstDevice : ' + str(self.dstDevice)]
-            str_list += ['dstArray : ' + str(self.dstArray)]
-            str_list += ['dstPitch : ' + str(self.dstPitch)]
-            str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
-            str_list += ['Height : ' + str(self.Height)]
+            try:
+                str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
+            except ValueError:
+                str_list += ['srcXInBytes : <ValueError>']
+            try:
+                str_list += ['srcY : ' + str(self.srcY)]
+            except ValueError:
+                str_list += ['srcY : <ValueError>']
+            try:
+                str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
+            except ValueError:
+                str_list += ['srcMemoryType : <ValueError>']
+            try:
+                str_list += ['srcHost : ' + hex(self.srcHost)]
+            except ValueError:
+                str_list += ['srcHost : <ValueError>']
+            try:
+                str_list += ['srcDevice : ' + str(self.srcDevice)]
+            except ValueError:
+                str_list += ['srcDevice : <ValueError>']
+            try:
+                str_list += ['srcArray : ' + str(self.srcArray)]
+            except ValueError:
+                str_list += ['srcArray : <ValueError>']
+            try:
+                str_list += ['srcPitch : ' + str(self.srcPitch)]
+            except ValueError:
+                str_list += ['srcPitch : <ValueError>']
+            try:
+                str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
+            except ValueError:
+                str_list += ['dstXInBytes : <ValueError>']
+            try:
+                str_list += ['dstY : ' + str(self.dstY)]
+            except ValueError:
+                str_list += ['dstY : <ValueError>']
+            try:
+                str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
+            except ValueError:
+                str_list += ['dstMemoryType : <ValueError>']
+            try:
+                str_list += ['dstHost : ' + hex(self.dstHost)]
+            except ValueError:
+                str_list += ['dstHost : <ValueError>']
+            try:
+                str_list += ['dstDevice : ' + str(self.dstDevice)]
+            except ValueError:
+                str_list += ['dstDevice : <ValueError>']
+            try:
+                str_list += ['dstArray : ' + str(self.dstArray)]
+            except ValueError:
+                str_list += ['dstArray : <ValueError>']
+            try:
+                str_list += ['dstPitch : ' + str(self.dstPitch)]
+            except ValueError:
+                str_list += ['dstPitch : <ValueError>']
+            try:
+                str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
+            except ValueError:
+                str_list += ['WidthInBytes : <ValueError>']
+            try:
+                str_list += ['Height : ' + str(self.Height)]
+            except ValueError:
+                str_list += ['Height : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def srcXInBytes(self):
         return self._ptr[0].srcXInBytes
     @srcXInBytes.setter
     def srcXInBytes(self, size_t srcXInBytes):
-        pass
         self._ptr[0].srcXInBytes = srcXInBytes
     @property
     def srcY(self):
         return self._ptr[0].srcY
     @srcY.setter
     def srcY(self, size_t srcY):
-        pass
         self._ptr[0].srcY = srcY
     @property
     def srcMemoryType(self):
         return CUmemorytype(self._ptr[0].srcMemoryType)
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].srcMemoryType = srcMemoryType.value
     @property
     def srcHost(self):
         return <void_ptr>self._ptr[0].srcHost
     @srcHost.setter
     def srcHost(self, srcHost):
-        _csrcHost = utils.HelperInputVoidPtr(srcHost)
-        self._ptr[0].srcHost = <void*><void_ptr>_csrcHost.cptr
+        _cysrcHost = utils.HelperInputVoidPtr(srcHost)
+        self._ptr[0].srcHost = <void*><void_ptr>_cysrcHost.cptr
     @property
     def srcDevice(self):
         return self._srcDevice
     @srcDevice.setter
     def srcDevice(self, srcDevice):
-        cdef ccuda.CUdeviceptr csrcDevice
+        cdef cydriver.CUdeviceptr cysrcDevice
         if srcDevice is None:
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(srcDevice, (CUdeviceptr)):
             psrcDevice = int(srcDevice)
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
         else:
             psrcDevice = int(CUdeviceptr(srcDevice))
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-        self._srcDevice._ptr[0] = csrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+        self._srcDevice._ptr[0] = cysrcDevice
+
     @property
     def srcArray(self):
         return self._srcArray
     @srcArray.setter
     def srcArray(self, srcArray):
-        cdef ccuda.CUarray csrcArray
+        cdef cydriver.CUarray cysrcArray
         if srcArray is None:
-            csrcArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(srcArray, (CUarray)):
+            cysrcArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(srcArray, (CUarray,)):
             psrcArray = int(srcArray)
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
         else:
             psrcArray = int(CUarray(srcArray))
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-        self._srcArray._ptr[0] = csrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+        self._srcArray._ptr[0] = cysrcArray
     @property
     def srcPitch(self):
         return self._ptr[0].srcPitch
     @srcPitch.setter
     def srcPitch(self, size_t srcPitch):
-        pass
         self._ptr[0].srcPitch = srcPitch
     @property
     def dstXInBytes(self):
         return self._ptr[0].dstXInBytes
     @dstXInBytes.setter
     def dstXInBytes(self, size_t dstXInBytes):
-        pass
         self._ptr[0].dstXInBytes = dstXInBytes
     @property
     def dstY(self):
         return self._ptr[0].dstY
     @dstY.setter
     def dstY(self, size_t dstY):
-        pass
         self._ptr[0].dstY = dstY
     @property
     def dstMemoryType(self):
         return CUmemorytype(self._ptr[0].dstMemoryType)
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].dstMemoryType = dstMemoryType.value
     @property
     def dstHost(self):
         return <void_ptr>self._ptr[0].dstHost
     @dstHost.setter
     def dstHost(self, dstHost):
-        _cdstHost = utils.HelperInputVoidPtr(dstHost)
-        self._ptr[0].dstHost = <void*><void_ptr>_cdstHost.cptr
+        _cydstHost = utils.HelperInputVoidPtr(dstHost)
+        self._ptr[0].dstHost = <void*><void_ptr>_cydstHost.cptr
     @property
     def dstDevice(self):
         return self._dstDevice
     @dstDevice.setter
     def dstDevice(self, dstDevice):
-        cdef ccuda.CUdeviceptr cdstDevice
+        cdef cydriver.CUdeviceptr cydstDevice
         if dstDevice is None:
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(dstDevice, (CUdeviceptr)):
             pdstDevice = int(dstDevice)
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
         else:
             pdstDevice = int(CUdeviceptr(dstDevice))
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-        self._dstDevice._ptr[0] = cdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+        self._dstDevice._ptr[0] = cydstDevice
+
     @property
     def dstArray(self):
         return self._dstArray
     @dstArray.setter
     def dstArray(self, dstArray):
-        cdef ccuda.CUarray cdstArray
+        cdef cydriver.CUarray cydstArray
         if dstArray is None:
-            cdstArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(dstArray, (CUarray)):
+            cydstArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(dstArray, (CUarray,)):
             pdstArray = int(dstArray)
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
         else:
             pdstArray = int(CUarray(dstArray))
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-        self._dstArray._ptr[0] = cdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+        self._dstArray._ptr[0] = cydstArray
     @property
     def dstPitch(self):
         return self._ptr[0].dstPitch
     @dstPitch.setter
     def dstPitch(self, size_t dstPitch):
-        pass
         self._ptr[0].dstPitch = dstPitch
     @property
     def WidthInBytes(self):
         return self._ptr[0].WidthInBytes
     @WidthInBytes.setter
     def WidthInBytes(self, size_t WidthInBytes):
-        pass
         self._ptr[0].WidthInBytes = WidthInBytes
     @property
     def Height(self):
         return self._ptr[0].Height
     @Height.setter
     def Height(self, size_t Height):
-        pass
         self._ptr[0].Height = Height
 {{endif}}
-{{if 'CUDA_MEMCPY3D_st' in found_types}}
+{{if 'struct CUDA_MEMCPY3D_st' in found_types}}
 
 cdef class CUDA_MEMCPY3D_st:
     """
@@ -7535,7 +7924,7 @@ cdef class CUDA_MEMCPY3D_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_MEMCPY3D_st *>_ptr
+            self._ptr = <cydriver.CUDA_MEMCPY3D_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._srcDevice = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].srcDevice)
         self._srcArray = CUarray(_ptr=<void_ptr>&self._ptr[0].srcArray)
@@ -7548,244 +7937,303 @@ cdef class CUDA_MEMCPY3D_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
-            str_list += ['srcY : ' + str(self.srcY)]
-            str_list += ['srcZ : ' + str(self.srcZ)]
-            str_list += ['srcLOD : ' + str(self.srcLOD)]
-            str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
-            str_list += ['srcHost : ' + hex(self.srcHost)]
-            str_list += ['srcDevice : ' + str(self.srcDevice)]
-            str_list += ['srcArray : ' + str(self.srcArray)]
-            str_list += ['reserved0 : ' + hex(self.reserved0)]
-            str_list += ['srcPitch : ' + str(self.srcPitch)]
-            str_list += ['srcHeight : ' + str(self.srcHeight)]
-            str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
-            str_list += ['dstY : ' + str(self.dstY)]
-            str_list += ['dstZ : ' + str(self.dstZ)]
-            str_list += ['dstLOD : ' + str(self.dstLOD)]
-            str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
-            str_list += ['dstHost : ' + hex(self.dstHost)]
-            str_list += ['dstDevice : ' + str(self.dstDevice)]
-            str_list += ['dstArray : ' + str(self.dstArray)]
-            str_list += ['reserved1 : ' + hex(self.reserved1)]
-            str_list += ['dstPitch : ' + str(self.dstPitch)]
-            str_list += ['dstHeight : ' + str(self.dstHeight)]
-            str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
-            str_list += ['Height : ' + str(self.Height)]
-            str_list += ['Depth : ' + str(self.Depth)]
+            try:
+                str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
+            except ValueError:
+                str_list += ['srcXInBytes : <ValueError>']
+            try:
+                str_list += ['srcY : ' + str(self.srcY)]
+            except ValueError:
+                str_list += ['srcY : <ValueError>']
+            try:
+                str_list += ['srcZ : ' + str(self.srcZ)]
+            except ValueError:
+                str_list += ['srcZ : <ValueError>']
+            try:
+                str_list += ['srcLOD : ' + str(self.srcLOD)]
+            except ValueError:
+                str_list += ['srcLOD : <ValueError>']
+            try:
+                str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
+            except ValueError:
+                str_list += ['srcMemoryType : <ValueError>']
+            try:
+                str_list += ['srcHost : ' + hex(self.srcHost)]
+            except ValueError:
+                str_list += ['srcHost : <ValueError>']
+            try:
+                str_list += ['srcDevice : ' + str(self.srcDevice)]
+            except ValueError:
+                str_list += ['srcDevice : <ValueError>']
+            try:
+                str_list += ['srcArray : ' + str(self.srcArray)]
+            except ValueError:
+                str_list += ['srcArray : <ValueError>']
+            try:
+                str_list += ['reserved0 : ' + hex(self.reserved0)]
+            except ValueError:
+                str_list += ['reserved0 : <ValueError>']
+            try:
+                str_list += ['srcPitch : ' + str(self.srcPitch)]
+            except ValueError:
+                str_list += ['srcPitch : <ValueError>']
+            try:
+                str_list += ['srcHeight : ' + str(self.srcHeight)]
+            except ValueError:
+                str_list += ['srcHeight : <ValueError>']
+            try:
+                str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
+            except ValueError:
+                str_list += ['dstXInBytes : <ValueError>']
+            try:
+                str_list += ['dstY : ' + str(self.dstY)]
+            except ValueError:
+                str_list += ['dstY : <ValueError>']
+            try:
+                str_list += ['dstZ : ' + str(self.dstZ)]
+            except ValueError:
+                str_list += ['dstZ : <ValueError>']
+            try:
+                str_list += ['dstLOD : ' + str(self.dstLOD)]
+            except ValueError:
+                str_list += ['dstLOD : <ValueError>']
+            try:
+                str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
+            except ValueError:
+                str_list += ['dstMemoryType : <ValueError>']
+            try:
+                str_list += ['dstHost : ' + hex(self.dstHost)]
+            except ValueError:
+                str_list += ['dstHost : <ValueError>']
+            try:
+                str_list += ['dstDevice : ' + str(self.dstDevice)]
+            except ValueError:
+                str_list += ['dstDevice : <ValueError>']
+            try:
+                str_list += ['dstArray : ' + str(self.dstArray)]
+            except ValueError:
+                str_list += ['dstArray : <ValueError>']
+            try:
+                str_list += ['reserved1 : ' + hex(self.reserved1)]
+            except ValueError:
+                str_list += ['reserved1 : <ValueError>']
+            try:
+                str_list += ['dstPitch : ' + str(self.dstPitch)]
+            except ValueError:
+                str_list += ['dstPitch : <ValueError>']
+            try:
+                str_list += ['dstHeight : ' + str(self.dstHeight)]
+            except ValueError:
+                str_list += ['dstHeight : <ValueError>']
+            try:
+                str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
+            except ValueError:
+                str_list += ['WidthInBytes : <ValueError>']
+            try:
+                str_list += ['Height : ' + str(self.Height)]
+            except ValueError:
+                str_list += ['Height : <ValueError>']
+            try:
+                str_list += ['Depth : ' + str(self.Depth)]
+            except ValueError:
+                str_list += ['Depth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def srcXInBytes(self):
         return self._ptr[0].srcXInBytes
     @srcXInBytes.setter
     def srcXInBytes(self, size_t srcXInBytes):
-        pass
         self._ptr[0].srcXInBytes = srcXInBytes
     @property
     def srcY(self):
         return self._ptr[0].srcY
     @srcY.setter
     def srcY(self, size_t srcY):
-        pass
         self._ptr[0].srcY = srcY
     @property
     def srcZ(self):
         return self._ptr[0].srcZ
     @srcZ.setter
     def srcZ(self, size_t srcZ):
-        pass
         self._ptr[0].srcZ = srcZ
     @property
     def srcLOD(self):
         return self._ptr[0].srcLOD
     @srcLOD.setter
     def srcLOD(self, size_t srcLOD):
-        pass
         self._ptr[0].srcLOD = srcLOD
     @property
     def srcMemoryType(self):
         return CUmemorytype(self._ptr[0].srcMemoryType)
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].srcMemoryType = srcMemoryType.value
     @property
     def srcHost(self):
         return <void_ptr>self._ptr[0].srcHost
     @srcHost.setter
     def srcHost(self, srcHost):
-        _csrcHost = utils.HelperInputVoidPtr(srcHost)
-        self._ptr[0].srcHost = <void*><void_ptr>_csrcHost.cptr
+        _cysrcHost = utils.HelperInputVoidPtr(srcHost)
+        self._ptr[0].srcHost = <void*><void_ptr>_cysrcHost.cptr
     @property
     def srcDevice(self):
         return self._srcDevice
     @srcDevice.setter
     def srcDevice(self, srcDevice):
-        cdef ccuda.CUdeviceptr csrcDevice
+        cdef cydriver.CUdeviceptr cysrcDevice
         if srcDevice is None:
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(srcDevice, (CUdeviceptr)):
             psrcDevice = int(srcDevice)
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
         else:
             psrcDevice = int(CUdeviceptr(srcDevice))
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-        self._srcDevice._ptr[0] = csrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+        self._srcDevice._ptr[0] = cysrcDevice
+
     @property
     def srcArray(self):
         return self._srcArray
     @srcArray.setter
     def srcArray(self, srcArray):
-        cdef ccuda.CUarray csrcArray
+        cdef cydriver.CUarray cysrcArray
         if srcArray is None:
-            csrcArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(srcArray, (CUarray)):
+            cysrcArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(srcArray, (CUarray,)):
             psrcArray = int(srcArray)
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
         else:
             psrcArray = int(CUarray(srcArray))
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-        self._srcArray._ptr[0] = csrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+        self._srcArray._ptr[0] = cysrcArray
     @property
     def reserved0(self):
         return <void_ptr>self._ptr[0].reserved0
     @reserved0.setter
     def reserved0(self, reserved0):
-        _creserved0 = utils.HelperInputVoidPtr(reserved0)
-        self._ptr[0].reserved0 = <void*><void_ptr>_creserved0.cptr
+        _cyreserved0 = utils.HelperInputVoidPtr(reserved0)
+        self._ptr[0].reserved0 = <void*><void_ptr>_cyreserved0.cptr
     @property
     def srcPitch(self):
         return self._ptr[0].srcPitch
     @srcPitch.setter
     def srcPitch(self, size_t srcPitch):
-        pass
         self._ptr[0].srcPitch = srcPitch
     @property
     def srcHeight(self):
         return self._ptr[0].srcHeight
     @srcHeight.setter
     def srcHeight(self, size_t srcHeight):
-        pass
         self._ptr[0].srcHeight = srcHeight
     @property
     def dstXInBytes(self):
         return self._ptr[0].dstXInBytes
     @dstXInBytes.setter
     def dstXInBytes(self, size_t dstXInBytes):
-        pass
         self._ptr[0].dstXInBytes = dstXInBytes
     @property
     def dstY(self):
         return self._ptr[0].dstY
     @dstY.setter
     def dstY(self, size_t dstY):
-        pass
         self._ptr[0].dstY = dstY
     @property
     def dstZ(self):
         return self._ptr[0].dstZ
     @dstZ.setter
     def dstZ(self, size_t dstZ):
-        pass
         self._ptr[0].dstZ = dstZ
     @property
     def dstLOD(self):
         return self._ptr[0].dstLOD
     @dstLOD.setter
     def dstLOD(self, size_t dstLOD):
-        pass
         self._ptr[0].dstLOD = dstLOD
     @property
     def dstMemoryType(self):
         return CUmemorytype(self._ptr[0].dstMemoryType)
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].dstMemoryType = dstMemoryType.value
     @property
     def dstHost(self):
         return <void_ptr>self._ptr[0].dstHost
     @dstHost.setter
     def dstHost(self, dstHost):
-        _cdstHost = utils.HelperInputVoidPtr(dstHost)
-        self._ptr[0].dstHost = <void*><void_ptr>_cdstHost.cptr
+        _cydstHost = utils.HelperInputVoidPtr(dstHost)
+        self._ptr[0].dstHost = <void*><void_ptr>_cydstHost.cptr
     @property
     def dstDevice(self):
         return self._dstDevice
     @dstDevice.setter
     def dstDevice(self, dstDevice):
-        cdef ccuda.CUdeviceptr cdstDevice
+        cdef cydriver.CUdeviceptr cydstDevice
         if dstDevice is None:
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(dstDevice, (CUdeviceptr)):
             pdstDevice = int(dstDevice)
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
         else:
             pdstDevice = int(CUdeviceptr(dstDevice))
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-        self._dstDevice._ptr[0] = cdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+        self._dstDevice._ptr[0] = cydstDevice
+
     @property
     def dstArray(self):
         return self._dstArray
     @dstArray.setter
     def dstArray(self, dstArray):
-        cdef ccuda.CUarray cdstArray
+        cdef cydriver.CUarray cydstArray
         if dstArray is None:
-            cdstArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(dstArray, (CUarray)):
+            cydstArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(dstArray, (CUarray,)):
             pdstArray = int(dstArray)
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
         else:
             pdstArray = int(CUarray(dstArray))
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-        self._dstArray._ptr[0] = cdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+        self._dstArray._ptr[0] = cydstArray
     @property
     def reserved1(self):
         return <void_ptr>self._ptr[0].reserved1
     @reserved1.setter
     def reserved1(self, reserved1):
-        _creserved1 = utils.HelperInputVoidPtr(reserved1)
-        self._ptr[0].reserved1 = <void*><void_ptr>_creserved1.cptr
+        _cyreserved1 = utils.HelperInputVoidPtr(reserved1)
+        self._ptr[0].reserved1 = <void*><void_ptr>_cyreserved1.cptr
     @property
     def dstPitch(self):
         return self._ptr[0].dstPitch
     @dstPitch.setter
     def dstPitch(self, size_t dstPitch):
-        pass
         self._ptr[0].dstPitch = dstPitch
     @property
     def dstHeight(self):
         return self._ptr[0].dstHeight
     @dstHeight.setter
     def dstHeight(self, size_t dstHeight):
-        pass
         self._ptr[0].dstHeight = dstHeight
     @property
     def WidthInBytes(self):
         return self._ptr[0].WidthInBytes
     @WidthInBytes.setter
     def WidthInBytes(self, size_t WidthInBytes):
-        pass
         self._ptr[0].WidthInBytes = WidthInBytes
     @property
     def Height(self):
         return self._ptr[0].Height
     @Height.setter
     def Height(self, size_t Height):
-        pass
         self._ptr[0].Height = Height
     @property
     def Depth(self):
         return self._ptr[0].Depth
     @Depth.setter
     def Depth(self, size_t Depth):
-        pass
         self._ptr[0].Depth = Depth
 {{endif}}
-{{if 'CUDA_MEMCPY3D_PEER_st' in found_types}}
+{{if 'struct CUDA_MEMCPY3D_PEER_st' in found_types}}
 
 cdef class CUDA_MEMCPY3D_PEER_st:
     """
@@ -7856,7 +8304,7 @@ cdef class CUDA_MEMCPY3D_PEER_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_MEMCPY3D_PEER_st *>_ptr
+            self._ptr = <cydriver.CUDA_MEMCPY3D_PEER_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._srcDevice = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].srcDevice)
         self._srcArray = CUarray(_ptr=<void_ptr>&self._ptr[0].srcArray)
@@ -7871,260 +8319,319 @@ cdef class CUDA_MEMCPY3D_PEER_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
-            str_list += ['srcY : ' + str(self.srcY)]
-            str_list += ['srcZ : ' + str(self.srcZ)]
-            str_list += ['srcLOD : ' + str(self.srcLOD)]
-            str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
-            str_list += ['srcHost : ' + hex(self.srcHost)]
-            str_list += ['srcDevice : ' + str(self.srcDevice)]
-            str_list += ['srcArray : ' + str(self.srcArray)]
-            str_list += ['srcContext : ' + str(self.srcContext)]
-            str_list += ['srcPitch : ' + str(self.srcPitch)]
-            str_list += ['srcHeight : ' + str(self.srcHeight)]
-            str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
-            str_list += ['dstY : ' + str(self.dstY)]
-            str_list += ['dstZ : ' + str(self.dstZ)]
-            str_list += ['dstLOD : ' + str(self.dstLOD)]
-            str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
-            str_list += ['dstHost : ' + hex(self.dstHost)]
-            str_list += ['dstDevice : ' + str(self.dstDevice)]
-            str_list += ['dstArray : ' + str(self.dstArray)]
-            str_list += ['dstContext : ' + str(self.dstContext)]
-            str_list += ['dstPitch : ' + str(self.dstPitch)]
-            str_list += ['dstHeight : ' + str(self.dstHeight)]
-            str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
-            str_list += ['Height : ' + str(self.Height)]
-            str_list += ['Depth : ' + str(self.Depth)]
+            try:
+                str_list += ['srcXInBytes : ' + str(self.srcXInBytes)]
+            except ValueError:
+                str_list += ['srcXInBytes : <ValueError>']
+            try:
+                str_list += ['srcY : ' + str(self.srcY)]
+            except ValueError:
+                str_list += ['srcY : <ValueError>']
+            try:
+                str_list += ['srcZ : ' + str(self.srcZ)]
+            except ValueError:
+                str_list += ['srcZ : <ValueError>']
+            try:
+                str_list += ['srcLOD : ' + str(self.srcLOD)]
+            except ValueError:
+                str_list += ['srcLOD : <ValueError>']
+            try:
+                str_list += ['srcMemoryType : ' + str(self.srcMemoryType)]
+            except ValueError:
+                str_list += ['srcMemoryType : <ValueError>']
+            try:
+                str_list += ['srcHost : ' + hex(self.srcHost)]
+            except ValueError:
+                str_list += ['srcHost : <ValueError>']
+            try:
+                str_list += ['srcDevice : ' + str(self.srcDevice)]
+            except ValueError:
+                str_list += ['srcDevice : <ValueError>']
+            try:
+                str_list += ['srcArray : ' + str(self.srcArray)]
+            except ValueError:
+                str_list += ['srcArray : <ValueError>']
+            try:
+                str_list += ['srcContext : ' + str(self.srcContext)]
+            except ValueError:
+                str_list += ['srcContext : <ValueError>']
+            try:
+                str_list += ['srcPitch : ' + str(self.srcPitch)]
+            except ValueError:
+                str_list += ['srcPitch : <ValueError>']
+            try:
+                str_list += ['srcHeight : ' + str(self.srcHeight)]
+            except ValueError:
+                str_list += ['srcHeight : <ValueError>']
+            try:
+                str_list += ['dstXInBytes : ' + str(self.dstXInBytes)]
+            except ValueError:
+                str_list += ['dstXInBytes : <ValueError>']
+            try:
+                str_list += ['dstY : ' + str(self.dstY)]
+            except ValueError:
+                str_list += ['dstY : <ValueError>']
+            try:
+                str_list += ['dstZ : ' + str(self.dstZ)]
+            except ValueError:
+                str_list += ['dstZ : <ValueError>']
+            try:
+                str_list += ['dstLOD : ' + str(self.dstLOD)]
+            except ValueError:
+                str_list += ['dstLOD : <ValueError>']
+            try:
+                str_list += ['dstMemoryType : ' + str(self.dstMemoryType)]
+            except ValueError:
+                str_list += ['dstMemoryType : <ValueError>']
+            try:
+                str_list += ['dstHost : ' + hex(self.dstHost)]
+            except ValueError:
+                str_list += ['dstHost : <ValueError>']
+            try:
+                str_list += ['dstDevice : ' + str(self.dstDevice)]
+            except ValueError:
+                str_list += ['dstDevice : <ValueError>']
+            try:
+                str_list += ['dstArray : ' + str(self.dstArray)]
+            except ValueError:
+                str_list += ['dstArray : <ValueError>']
+            try:
+                str_list += ['dstContext : ' + str(self.dstContext)]
+            except ValueError:
+                str_list += ['dstContext : <ValueError>']
+            try:
+                str_list += ['dstPitch : ' + str(self.dstPitch)]
+            except ValueError:
+                str_list += ['dstPitch : <ValueError>']
+            try:
+                str_list += ['dstHeight : ' + str(self.dstHeight)]
+            except ValueError:
+                str_list += ['dstHeight : <ValueError>']
+            try:
+                str_list += ['WidthInBytes : ' + str(self.WidthInBytes)]
+            except ValueError:
+                str_list += ['WidthInBytes : <ValueError>']
+            try:
+                str_list += ['Height : ' + str(self.Height)]
+            except ValueError:
+                str_list += ['Height : <ValueError>']
+            try:
+                str_list += ['Depth : ' + str(self.Depth)]
+            except ValueError:
+                str_list += ['Depth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def srcXInBytes(self):
         return self._ptr[0].srcXInBytes
     @srcXInBytes.setter
     def srcXInBytes(self, size_t srcXInBytes):
-        pass
         self._ptr[0].srcXInBytes = srcXInBytes
     @property
     def srcY(self):
         return self._ptr[0].srcY
     @srcY.setter
     def srcY(self, size_t srcY):
-        pass
         self._ptr[0].srcY = srcY
     @property
     def srcZ(self):
         return self._ptr[0].srcZ
     @srcZ.setter
     def srcZ(self, size_t srcZ):
-        pass
         self._ptr[0].srcZ = srcZ
     @property
     def srcLOD(self):
         return self._ptr[0].srcLOD
     @srcLOD.setter
     def srcLOD(self, size_t srcLOD):
-        pass
         self._ptr[0].srcLOD = srcLOD
     @property
     def srcMemoryType(self):
         return CUmemorytype(self._ptr[0].srcMemoryType)
     @srcMemoryType.setter
     def srcMemoryType(self, srcMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].srcMemoryType = srcMemoryType.value
     @property
     def srcHost(self):
         return <void_ptr>self._ptr[0].srcHost
     @srcHost.setter
     def srcHost(self, srcHost):
-        _csrcHost = utils.HelperInputVoidPtr(srcHost)
-        self._ptr[0].srcHost = <void*><void_ptr>_csrcHost.cptr
+        _cysrcHost = utils.HelperInputVoidPtr(srcHost)
+        self._ptr[0].srcHost = <void*><void_ptr>_cysrcHost.cptr
     @property
     def srcDevice(self):
         return self._srcDevice
     @srcDevice.setter
     def srcDevice(self, srcDevice):
-        cdef ccuda.CUdeviceptr csrcDevice
+        cdef cydriver.CUdeviceptr cysrcDevice
         if srcDevice is None:
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(srcDevice, (CUdeviceptr)):
             psrcDevice = int(srcDevice)
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
         else:
             psrcDevice = int(CUdeviceptr(srcDevice))
-            csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-        self._srcDevice._ptr[0] = csrcDevice
+            cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+        self._srcDevice._ptr[0] = cysrcDevice
+
     @property
     def srcArray(self):
         return self._srcArray
     @srcArray.setter
     def srcArray(self, srcArray):
-        cdef ccuda.CUarray csrcArray
+        cdef cydriver.CUarray cysrcArray
         if srcArray is None:
-            csrcArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(srcArray, (CUarray)):
+            cysrcArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(srcArray, (CUarray,)):
             psrcArray = int(srcArray)
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
         else:
             psrcArray = int(CUarray(srcArray))
-            csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-        self._srcArray._ptr[0] = csrcArray
+            cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+        self._srcArray._ptr[0] = cysrcArray
     @property
     def srcContext(self):
         return self._srcContext
     @srcContext.setter
     def srcContext(self, srcContext):
-        cdef ccuda.CUcontext csrcContext
+        cdef cydriver.CUcontext cysrcContext
         if srcContext is None:
-            csrcContext = <ccuda.CUcontext><void_ptr>0
-        elif isinstance(srcContext, (CUcontext)):
+            cysrcContext = <cydriver.CUcontext><void_ptr>0
+        elif isinstance(srcContext, (CUcontext,)):
             psrcContext = int(srcContext)
-            csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
+            cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
         else:
             psrcContext = int(CUcontext(srcContext))
-            csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
-        self._srcContext._ptr[0] = csrcContext
+            cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
+        self._srcContext._ptr[0] = cysrcContext
     @property
     def srcPitch(self):
         return self._ptr[0].srcPitch
     @srcPitch.setter
     def srcPitch(self, size_t srcPitch):
-        pass
         self._ptr[0].srcPitch = srcPitch
     @property
     def srcHeight(self):
         return self._ptr[0].srcHeight
     @srcHeight.setter
     def srcHeight(self, size_t srcHeight):
-        pass
         self._ptr[0].srcHeight = srcHeight
     @property
     def dstXInBytes(self):
         return self._ptr[0].dstXInBytes
     @dstXInBytes.setter
     def dstXInBytes(self, size_t dstXInBytes):
-        pass
         self._ptr[0].dstXInBytes = dstXInBytes
     @property
     def dstY(self):
         return self._ptr[0].dstY
     @dstY.setter
     def dstY(self, size_t dstY):
-        pass
         self._ptr[0].dstY = dstY
     @property
     def dstZ(self):
         return self._ptr[0].dstZ
     @dstZ.setter
     def dstZ(self, size_t dstZ):
-        pass
         self._ptr[0].dstZ = dstZ
     @property
     def dstLOD(self):
         return self._ptr[0].dstLOD
     @dstLOD.setter
     def dstLOD(self, size_t dstLOD):
-        pass
         self._ptr[0].dstLOD = dstLOD
     @property
     def dstMemoryType(self):
         return CUmemorytype(self._ptr[0].dstMemoryType)
     @dstMemoryType.setter
     def dstMemoryType(self, dstMemoryType not None : CUmemorytype):
-        pass
         self._ptr[0].dstMemoryType = dstMemoryType.value
     @property
     def dstHost(self):
         return <void_ptr>self._ptr[0].dstHost
     @dstHost.setter
     def dstHost(self, dstHost):
-        _cdstHost = utils.HelperInputVoidPtr(dstHost)
-        self._ptr[0].dstHost = <void*><void_ptr>_cdstHost.cptr
+        _cydstHost = utils.HelperInputVoidPtr(dstHost)
+        self._ptr[0].dstHost = <void*><void_ptr>_cydstHost.cptr
     @property
     def dstDevice(self):
         return self._dstDevice
     @dstDevice.setter
     def dstDevice(self, dstDevice):
-        cdef ccuda.CUdeviceptr cdstDevice
+        cdef cydriver.CUdeviceptr cydstDevice
         if dstDevice is None:
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(dstDevice, (CUdeviceptr)):
             pdstDevice = int(dstDevice)
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
         else:
             pdstDevice = int(CUdeviceptr(dstDevice))
-            cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-        self._dstDevice._ptr[0] = cdstDevice
+            cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+        self._dstDevice._ptr[0] = cydstDevice
+
     @property
     def dstArray(self):
         return self._dstArray
     @dstArray.setter
     def dstArray(self, dstArray):
-        cdef ccuda.CUarray cdstArray
+        cdef cydriver.CUarray cydstArray
         if dstArray is None:
-            cdstArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(dstArray, (CUarray)):
+            cydstArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(dstArray, (CUarray,)):
             pdstArray = int(dstArray)
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
         else:
             pdstArray = int(CUarray(dstArray))
-            cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-        self._dstArray._ptr[0] = cdstArray
+            cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+        self._dstArray._ptr[0] = cydstArray
     @property
     def dstContext(self):
         return self._dstContext
     @dstContext.setter
     def dstContext(self, dstContext):
-        cdef ccuda.CUcontext cdstContext
+        cdef cydriver.CUcontext cydstContext
         if dstContext is None:
-            cdstContext = <ccuda.CUcontext><void_ptr>0
-        elif isinstance(dstContext, (CUcontext)):
+            cydstContext = <cydriver.CUcontext><void_ptr>0
+        elif isinstance(dstContext, (CUcontext,)):
             pdstContext = int(dstContext)
-            cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
+            cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
         else:
             pdstContext = int(CUcontext(dstContext))
-            cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
-        self._dstContext._ptr[0] = cdstContext
+            cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
+        self._dstContext._ptr[0] = cydstContext
     @property
     def dstPitch(self):
         return self._ptr[0].dstPitch
     @dstPitch.setter
     def dstPitch(self, size_t dstPitch):
-        pass
         self._ptr[0].dstPitch = dstPitch
     @property
     def dstHeight(self):
         return self._ptr[0].dstHeight
     @dstHeight.setter
     def dstHeight(self, size_t dstHeight):
-        pass
         self._ptr[0].dstHeight = dstHeight
     @property
     def WidthInBytes(self):
         return self._ptr[0].WidthInBytes
     @WidthInBytes.setter
     def WidthInBytes(self, size_t WidthInBytes):
-        pass
         self._ptr[0].WidthInBytes = WidthInBytes
     @property
     def Height(self):
         return self._ptr[0].Height
     @Height.setter
     def Height(self, size_t Height):
-        pass
         self._ptr[0].Height = Height
     @property
     def Depth(self):
         return self._ptr[0].Depth
     @Depth.setter
     def Depth(self, size_t Depth):
-        pass
         self._ptr[0].Depth = Depth
 {{endif}}
-{{if 'CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
+{{if 'struct CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
 
 cdef class CUDA_ARRAY_DESCRIPTOR_st:
     """
@@ -8151,7 +8658,7 @@ cdef class CUDA_ARRAY_DESCRIPTOR_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_ARRAY_DESCRIPTOR_st *>_ptr
+            self._ptr = <cydriver.CUDA_ARRAY_DESCRIPTOR_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -8161,44 +8668,51 @@ cdef class CUDA_ARRAY_DESCRIPTOR_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['Width : ' + str(self.Width)]
-            str_list += ['Height : ' + str(self.Height)]
-            str_list += ['Format : ' + str(self.Format)]
-            str_list += ['NumChannels : ' + str(self.NumChannels)]
+            try:
+                str_list += ['Width : ' + str(self.Width)]
+            except ValueError:
+                str_list += ['Width : <ValueError>']
+            try:
+                str_list += ['Height : ' + str(self.Height)]
+            except ValueError:
+                str_list += ['Height : <ValueError>']
+            try:
+                str_list += ['Format : ' + str(self.Format)]
+            except ValueError:
+                str_list += ['Format : <ValueError>']
+            try:
+                str_list += ['NumChannels : ' + str(self.NumChannels)]
+            except ValueError:
+                str_list += ['NumChannels : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def Width(self):
         return self._ptr[0].Width
     @Width.setter
     def Width(self, size_t Width):
-        pass
         self._ptr[0].Width = Width
     @property
     def Height(self):
         return self._ptr[0].Height
     @Height.setter
     def Height(self, size_t Height):
-        pass
         self._ptr[0].Height = Height
     @property
     def Format(self):
         return CUarray_format(self._ptr[0].Format)
     @Format.setter
     def Format(self, Format not None : CUarray_format):
-        pass
         self._ptr[0].Format = Format.value
     @property
     def NumChannels(self):
         return self._ptr[0].NumChannels
     @NumChannels.setter
     def NumChannels(self, unsigned int NumChannels):
-        pass
         self._ptr[0].NumChannels = NumChannels
 {{endif}}
-{{if 'CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
+{{if 'struct CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
 
 cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
     """
@@ -8229,7 +8743,7 @@ cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_ARRAY3D_DESCRIPTOR_st *>_ptr
+            self._ptr = <cydriver.CUDA_ARRAY3D_DESCRIPTOR_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -8239,64 +8753,74 @@ cdef class CUDA_ARRAY3D_DESCRIPTOR_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['Width : ' + str(self.Width)]
-            str_list += ['Height : ' + str(self.Height)]
-            str_list += ['Depth : ' + str(self.Depth)]
-            str_list += ['Format : ' + str(self.Format)]
-            str_list += ['NumChannels : ' + str(self.NumChannels)]
-            str_list += ['Flags : ' + str(self.Flags)]
+            try:
+                str_list += ['Width : ' + str(self.Width)]
+            except ValueError:
+                str_list += ['Width : <ValueError>']
+            try:
+                str_list += ['Height : ' + str(self.Height)]
+            except ValueError:
+                str_list += ['Height : <ValueError>']
+            try:
+                str_list += ['Depth : ' + str(self.Depth)]
+            except ValueError:
+                str_list += ['Depth : <ValueError>']
+            try:
+                str_list += ['Format : ' + str(self.Format)]
+            except ValueError:
+                str_list += ['Format : <ValueError>']
+            try:
+                str_list += ['NumChannels : ' + str(self.NumChannels)]
+            except ValueError:
+                str_list += ['NumChannels : <ValueError>']
+            try:
+                str_list += ['Flags : ' + str(self.Flags)]
+            except ValueError:
+                str_list += ['Flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def Width(self):
         return self._ptr[0].Width
     @Width.setter
     def Width(self, size_t Width):
-        pass
         self._ptr[0].Width = Width
     @property
     def Height(self):
         return self._ptr[0].Height
     @Height.setter
     def Height(self, size_t Height):
-        pass
         self._ptr[0].Height = Height
     @property
     def Depth(self):
         return self._ptr[0].Depth
     @Depth.setter
     def Depth(self, size_t Depth):
-        pass
         self._ptr[0].Depth = Depth
     @property
     def Format(self):
         return CUarray_format(self._ptr[0].Format)
     @Format.setter
     def Format(self, Format not None : CUarray_format):
-        pass
         self._ptr[0].Format = Format.value
     @property
     def NumChannels(self):
         return self._ptr[0].NumChannels
     @NumChannels.setter
     def NumChannels(self, unsigned int NumChannels):
-        pass
         self._ptr[0].NumChannels = NumChannels
     @property
     def Flags(self):
         return self._ptr[0].Flags
     @Flags.setter
     def Flags(self, unsigned int Flags):
-        pass
         self._ptr[0].Flags = Flags
 {{endif}}
-{{if 'CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
+{{if 'struct CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
 
-cdef class _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s:
+cdef class anon_struct2:
     """
-
     Attributes
     ----------
     width : unsigned int
@@ -8313,44 +8837,52 @@ cdef class _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st *>_ptr
+        self._ptr = <cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].tileExtent
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def width(self):
         return self._ptr[0].tileExtent.width
     @width.setter
     def width(self, unsigned int width):
-        pass
         self._ptr[0].tileExtent.width = width
     @property
     def height(self):
         return self._ptr[0].tileExtent.height
     @height.setter
     def height(self, unsigned int height):
-        pass
         self._ptr[0].tileExtent.height = height
     @property
     def depth(self):
         return self._ptr[0].tileExtent.depth
     @depth.setter
     def depth(self, unsigned int depth):
-        pass
         self._ptr[0].tileExtent.depth = depth
 {{endif}}
-{{if 'CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
+{{if 'struct CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
 
 cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
     """
@@ -8358,7 +8890,7 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
 
     Attributes
     ----------
-    tileExtent : _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s
+    tileExtent : anon_struct2
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins.
@@ -8380,9 +8912,9 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st *>_ptr
+            self._ptr = <cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._tileExtent = _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s(_ptr=<void_ptr>self._ptr)
+        self._tileExtent = anon_struct2(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -8390,56 +8922,61 @@ cdef class CUDA_ARRAY_SPARSE_PROPERTIES_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['tileExtent :\n' + '\n'.join(['    ' + line for line in str(self.tileExtent).splitlines()])]
-            str_list += ['miptailFirstLevel : ' + str(self.miptailFirstLevel)]
-            str_list += ['miptailSize : ' + str(self.miptailSize)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['tileExtent :\n' + '\n'.join(['    ' + line for line in str(self.tileExtent).splitlines()])]
+            except ValueError:
+                str_list += ['tileExtent : <ValueError>']
+            try:
+                str_list += ['miptailFirstLevel : ' + str(self.miptailFirstLevel)]
+            except ValueError:
+                str_list += ['miptailFirstLevel : <ValueError>']
+            try:
+                str_list += ['miptailSize : ' + str(self.miptailSize)]
+            except ValueError:
+                str_list += ['miptailSize : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def tileExtent(self):
         return self._tileExtent
     @tileExtent.setter
-    def tileExtent(self, tileExtent not None : _CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_v1_CUDA_ARRAY_SPARSE_PROPERTIES_st_tileExtent_s):
-        pass
-        for _attr in dir(tileExtent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._tileExtent, _attr, getattr(tileExtent, _attr))
+    def tileExtent(self, tileExtent not None : anon_struct2):
+        string.memcpy(&self._ptr[0].tileExtent, <cydriver.anon_struct2*><void_ptr>tileExtent.getPtr(), sizeof(self._ptr[0].tileExtent))
     @property
     def miptailFirstLevel(self):
         return self._ptr[0].miptailFirstLevel
     @miptailFirstLevel.setter
     def miptailFirstLevel(self, unsigned int miptailFirstLevel):
-        pass
         self._ptr[0].miptailFirstLevel = miptailFirstLevel
     @property
     def miptailSize(self):
         return self._ptr[0].miptailSize
     @miptailSize.setter
     def miptailSize(self, unsigned long long miptailSize):
-        pass
         self._ptr[0].miptailSize = miptailSize
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
+{{if 'struct CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
 
 cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
     """
@@ -8464,7 +9001,7 @@ cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st *>_ptr
+            self._ptr = <cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -8474,40 +9011,44 @@ cdef class CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['alignment : ' + str(self.alignment)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['alignment : ' + str(self.alignment)]
+            except ValueError:
+                str_list += ['alignment : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, size_t size):
-        pass
         self._ptr[0].size = size
     @property
     def alignment(self):
         return self._ptr[0].alignment
     @alignment.setter
     def alignment(self, size_t alignment):
-        pass
         self._ptr[0].alignment = alignment
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s:
+cdef class anon_struct3:
     """
-
     Attributes
     ----------
     hArray : CUarray
@@ -8520,40 +9061,44 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._hArray = CUarray(_ptr=<void_ptr>&self._ptr[0].res.array.hArray)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.array
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['hArray : ' + str(self.hArray)]
+            try:
+                str_list += ['hArray : ' + str(self.hArray)]
+            except ValueError:
+                str_list += ['hArray : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def hArray(self):
         return self._hArray
     @hArray.setter
     def hArray(self, hArray):
-        cdef ccuda.CUarray chArray
+        cdef cydriver.CUarray cyhArray
         if hArray is None:
-            chArray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(hArray, (CUarray)):
+            cyhArray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(hArray, (CUarray,)):
             phArray = int(hArray)
-            chArray = <ccuda.CUarray><void_ptr>phArray
+            cyhArray = <cydriver.CUarray><void_ptr>phArray
         else:
             phArray = int(CUarray(hArray))
-            chArray = <ccuda.CUarray><void_ptr>phArray
-        self._hArray._ptr[0] = chArray
+            cyhArray = <cydriver.CUarray><void_ptr>phArray
+        self._hArray._ptr[0] = cyhArray
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s:
+cdef class anon_struct4:
     """
-
     Attributes
     ----------
     hMipmappedArray : CUmipmappedArray
@@ -8566,40 +9111,44 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._hMipmappedArray = CUmipmappedArray(_ptr=<void_ptr>&self._ptr[0].res.mipmap.hMipmappedArray)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.mipmap
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['hMipmappedArray : ' + str(self.hMipmappedArray)]
+            try:
+                str_list += ['hMipmappedArray : ' + str(self.hMipmappedArray)]
+            except ValueError:
+                str_list += ['hMipmappedArray : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def hMipmappedArray(self):
         return self._hMipmappedArray
     @hMipmappedArray.setter
     def hMipmappedArray(self, hMipmappedArray):
-        cdef ccuda.CUmipmappedArray chMipmappedArray
+        cdef cydriver.CUmipmappedArray cyhMipmappedArray
         if hMipmappedArray is None:
-            chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>0
-        elif isinstance(hMipmappedArray, (CUmipmappedArray)):
+            cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>0
+        elif isinstance(hMipmappedArray, (CUmipmappedArray,)):
             phMipmappedArray = int(hMipmappedArray)
-            chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
+            cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
         else:
             phMipmappedArray = int(CUmipmappedArray(hMipmappedArray))
-            chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
-        self._hMipmappedArray._ptr[0] = chMipmappedArray
+            cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
+        self._hMipmappedArray._ptr[0] = cyhMipmappedArray
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s:
+cdef class anon_struct5:
     """
-
     Attributes
     ----------
     devPtr : CUdeviceptr
@@ -8618,64 +9167,75 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._devPtr = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].res.linear.devPtr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.linear
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['devPtr : ' + str(self.devPtr)]
-            str_list += ['format : ' + str(self.format)]
-            str_list += ['numChannels : ' + str(self.numChannels)]
-            str_list += ['sizeInBytes : ' + str(self.sizeInBytes)]
+            try:
+                str_list += ['devPtr : ' + str(self.devPtr)]
+            except ValueError:
+                str_list += ['devPtr : <ValueError>']
+            try:
+                str_list += ['format : ' + str(self.format)]
+            except ValueError:
+                str_list += ['format : <ValueError>']
+            try:
+                str_list += ['numChannels : ' + str(self.numChannels)]
+            except ValueError:
+                str_list += ['numChannels : <ValueError>']
+            try:
+                str_list += ['sizeInBytes : ' + str(self.sizeInBytes)]
+            except ValueError:
+                str_list += ['sizeInBytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def devPtr(self):
         return self._devPtr
     @devPtr.setter
     def devPtr(self, devPtr):
-        cdef ccuda.CUdeviceptr cdevPtr
+        cdef cydriver.CUdeviceptr cydevPtr
         if devPtr is None:
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(devPtr, (CUdeviceptr)):
             pdevPtr = int(devPtr)
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
         else:
             pdevPtr = int(CUdeviceptr(devPtr))
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-        self._devPtr._ptr[0] = cdevPtr
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
+        self._devPtr._ptr[0] = cydevPtr
+
     @property
     def format(self):
         return CUarray_format(self._ptr[0].res.linear.format)
     @format.setter
     def format(self, format not None : CUarray_format):
-        pass
         self._ptr[0].res.linear.format = format.value
     @property
     def numChannels(self):
         return self._ptr[0].res.linear.numChannels
     @numChannels.setter
     def numChannels(self, unsigned int numChannels):
-        pass
         self._ptr[0].res.linear.numChannels = numChannels
     @property
     def sizeInBytes(self):
         return self._ptr[0].res.linear.sizeInBytes
     @sizeInBytes.setter
     def sizeInBytes(self, size_t sizeInBytes):
-        pass
         self._ptr[0].res.linear.sizeInBytes = sizeInBytes
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s:
+cdef class anon_struct6:
     """
-
     Attributes
     ----------
     devPtr : CUdeviceptr
@@ -8698,80 +9258,95 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._devPtr = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].res.pitch2D.devPtr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.pitch2D
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['devPtr : ' + str(self.devPtr)]
-            str_list += ['format : ' + str(self.format)]
-            str_list += ['numChannels : ' + str(self.numChannels)]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['pitchInBytes : ' + str(self.pitchInBytes)]
+            try:
+                str_list += ['devPtr : ' + str(self.devPtr)]
+            except ValueError:
+                str_list += ['devPtr : <ValueError>']
+            try:
+                str_list += ['format : ' + str(self.format)]
+            except ValueError:
+                str_list += ['format : <ValueError>']
+            try:
+                str_list += ['numChannels : ' + str(self.numChannels)]
+            except ValueError:
+                str_list += ['numChannels : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['pitchInBytes : ' + str(self.pitchInBytes)]
+            except ValueError:
+                str_list += ['pitchInBytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def devPtr(self):
         return self._devPtr
     @devPtr.setter
     def devPtr(self, devPtr):
-        cdef ccuda.CUdeviceptr cdevPtr
+        cdef cydriver.CUdeviceptr cydevPtr
         if devPtr is None:
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(devPtr, (CUdeviceptr)):
             pdevPtr = int(devPtr)
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
         else:
             pdevPtr = int(CUdeviceptr(devPtr))
-            cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-        self._devPtr._ptr[0] = cdevPtr
+            cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
+        self._devPtr._ptr[0] = cydevPtr
+
     @property
     def format(self):
         return CUarray_format(self._ptr[0].res.pitch2D.format)
     @format.setter
     def format(self, format not None : CUarray_format):
-        pass
         self._ptr[0].res.pitch2D.format = format.value
     @property
     def numChannels(self):
         return self._ptr[0].res.pitch2D.numChannels
     @numChannels.setter
     def numChannels(self, unsigned int numChannels):
-        pass
         self._ptr[0].res.pitch2D.numChannels = numChannels
     @property
     def width(self):
         return self._ptr[0].res.pitch2D.width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].res.pitch2D.width = width
     @property
     def height(self):
         return self._ptr[0].res.pitch2D.height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].res.pitch2D.height = height
     @property
     def pitchInBytes(self):
         return self._ptr[0].res.pitch2D.pitchInBytes
     @pitchInBytes.setter
     def pitchInBytes(self, size_t pitchInBytes):
-        pass
         self._ptr[0].res.pitch2D.pitchInBytes = pitchInBytes
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s:
+cdef class anon_struct7:
     """
-
     Attributes
     ----------
     reserved : List[int]
@@ -8784,43 +9359,46 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.reserved
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return self._ptr[0].res.reserved.reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].res.reserved.reserved = reserved
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
-cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u:
+cdef class anon_union3:
     """
-
     Attributes
     ----------
-    array : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s
+    array : anon_struct3
 
-    mipmap : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s
+    mipmap : anon_struct4
 
-    linear : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s
+    linear : anon_struct5
 
-    pitch2D : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s
+    pitch2D : anon_struct6
 
-    reserved : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s
+    reserved : anon_struct7
 
 
     Methods
@@ -8830,84 +9408,76 @@ cdef class _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_re
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._array = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s(_ptr=<void_ptr>self._ptr)
-        self._mipmap = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s(_ptr=<void_ptr>self._ptr)
-        self._linear = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s(_ptr=<void_ptr>self._ptr)
-        self._pitch2D = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s(_ptr=<void_ptr>self._ptr)
-        self._reserved = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s(_ptr=<void_ptr>self._ptr)
+        self._array = anon_struct3(_ptr=<void_ptr>self._ptr)
+        self._mipmap = anon_struct4(_ptr=<void_ptr>self._ptr)
+        self._linear = anon_struct5(_ptr=<void_ptr>self._ptr)
+        self._pitch2D = anon_struct6(_ptr=<void_ptr>self._ptr)
+        self._reserved = anon_struct7(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['array :\n' + '\n'.join(['    ' + line for line in str(self.array).splitlines()])]
-            str_list += ['mipmap :\n' + '\n'.join(['    ' + line for line in str(self.mipmap).splitlines()])]
-            str_list += ['linear :\n' + '\n'.join(['    ' + line for line in str(self.linear).splitlines()])]
-            str_list += ['pitch2D :\n' + '\n'.join(['    ' + line for line in str(self.pitch2D).splitlines()])]
-            str_list += ['reserved :\n' + '\n'.join(['    ' + line for line in str(self.reserved).splitlines()])]
+            try:
+                str_list += ['array :\n' + '\n'.join(['    ' + line for line in str(self.array).splitlines()])]
+            except ValueError:
+                str_list += ['array : <ValueError>']
+            try:
+                str_list += ['mipmap :\n' + '\n'.join(['    ' + line for line in str(self.mipmap).splitlines()])]
+            except ValueError:
+                str_list += ['mipmap : <ValueError>']
+            try:
+                str_list += ['linear :\n' + '\n'.join(['    ' + line for line in str(self.linear).splitlines()])]
+            except ValueError:
+                str_list += ['linear : <ValueError>']
+            try:
+                str_list += ['pitch2D :\n' + '\n'.join(['    ' + line for line in str(self.pitch2D).splitlines()])]
+            except ValueError:
+                str_list += ['pitch2D : <ValueError>']
+            try:
+                str_list += ['reserved :\n' + '\n'.join(['    ' + line for line in str(self.reserved).splitlines()])]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def array(self):
         return self._array
     @array.setter
-    def array(self, array not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_array_s):
-        pass
-        for _attr in dir(array):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._array, _attr, getattr(array, _attr))
+    def array(self, array not None : anon_struct3):
+        string.memcpy(&self._ptr[0].res.array, <cydriver.anon_struct3*><void_ptr>array.getPtr(), sizeof(self._ptr[0].res.array))
     @property
     def mipmap(self):
         return self._mipmap
     @mipmap.setter
-    def mipmap(self, mipmap not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_mipmap_s):
-        pass
-        for _attr in dir(mipmap):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._mipmap, _attr, getattr(mipmap, _attr))
+    def mipmap(self, mipmap not None : anon_struct4):
+        string.memcpy(&self._ptr[0].res.mipmap, <cydriver.anon_struct4*><void_ptr>mipmap.getPtr(), sizeof(self._ptr[0].res.mipmap))
     @property
     def linear(self):
         return self._linear
     @linear.setter
-    def linear(self, linear not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_linear_s):
-        pass
-        for _attr in dir(linear):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._linear, _attr, getattr(linear, _attr))
+    def linear(self, linear not None : anon_struct5):
+        string.memcpy(&self._ptr[0].res.linear, <cydriver.anon_struct5*><void_ptr>linear.getPtr(), sizeof(self._ptr[0].res.linear))
     @property
     def pitch2D(self):
         return self._pitch2D
     @pitch2D.setter
-    def pitch2D(self, pitch2D not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_pitch2D_s):
-        pass
-        for _attr in dir(pitch2D):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._pitch2D, _attr, getattr(pitch2D, _attr))
+    def pitch2D(self, pitch2D not None : anon_struct6):
+        string.memcpy(&self._ptr[0].res.pitch2D, <cydriver.anon_struct6*><void_ptr>pitch2D.getPtr(), sizeof(self._ptr[0].res.pitch2D))
     @property
     def reserved(self):
         return self._reserved
     @reserved.setter
-    def reserved(self, reserved not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_res_reserved_s):
-        pass
-        for _attr in dir(reserved):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._reserved, _attr, getattr(reserved, _attr))
+    def reserved(self, reserved not None : anon_struct7):
+        string.memcpy(&self._ptr[0].res.reserved, <cydriver.anon_struct7*><void_ptr>reserved.getPtr(), sizeof(self._ptr[0].res.reserved))
 {{endif}}
-{{if 'CUDA_RESOURCE_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
 
 cdef class CUDA_RESOURCE_DESC_st:
     """
@@ -8917,7 +9487,7 @@ cdef class CUDA_RESOURCE_DESC_st:
     ----------
     resType : CUresourcetype
         Resource type
-    res : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u
+    res : anon_union3
 
     flags : unsigned int
         Flags (must be zero)
@@ -8930,52 +9500,55 @@ cdef class CUDA_RESOURCE_DESC_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUDA_RESOURCE_DESC_st *>calloc(1, sizeof(cydriver.CUDA_RESOURCE_DESC_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUDA_RESOURCE_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_RESOURCE_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._res = _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u(_ptr=<void_ptr>self._ptr)
+        self._res = anon_union3(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['resType : ' + str(self.resType)]
-            str_list += ['res :\n' + '\n'.join(['    ' + line for line in str(self.res).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['resType : ' + str(self.resType)]
+            except ValueError:
+                str_list += ['resType : <ValueError>']
+            try:
+                str_list += ['res :\n' + '\n'.join(['    ' + line for line in str(self.res).splitlines()])]
+            except ValueError:
+                str_list += ['res : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def resType(self):
         return CUresourcetype(self._ptr[0].resType)
     @resType.setter
     def resType(self, resType not None : CUresourcetype):
-        pass
         self._ptr[0].resType = resType.value
     @property
     def res(self):
         return self._res
     @res.setter
-    def res(self, res not None : _CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_v1_CUDA_RESOURCE_DESC_st_res_u):
-        pass
-        for _attr in dir(res):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._res, _attr, getattr(res, _attr))
+    def res(self, res not None : anon_union3):
+        string.memcpy(&self._ptr[0].res, <cydriver.anon_union3*><void_ptr>res.getPtr(), sizeof(self._ptr[0].res))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
 {{endif}}
-{{if 'CUDA_TEXTURE_DESC_st' in found_types}}
+{{if 'struct CUDA_TEXTURE_DESC_st' in found_types}}
 
 cdef class CUDA_TEXTURE_DESC_st:
     """
@@ -9014,7 +9587,7 @@ cdef class CUDA_TEXTURE_DESC_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_TEXTURE_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_TEXTURE_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9024,20 +9597,49 @@ cdef class CUDA_TEXTURE_DESC_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['addressMode : ' + str(self.addressMode)]
-            str_list += ['filterMode : ' + str(self.filterMode)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
-            str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
-            str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
-            str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
-            str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
-            str_list += ['borderColor : ' + str(self.borderColor)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['addressMode : ' + str(self.addressMode)]
+            except ValueError:
+                str_list += ['addressMode : <ValueError>']
+            try:
+                str_list += ['filterMode : ' + str(self.filterMode)]
+            except ValueError:
+                str_list += ['filterMode : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
+            except ValueError:
+                str_list += ['maxAnisotropy : <ValueError>']
+            try:
+                str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
+            except ValueError:
+                str_list += ['mipmapFilterMode : <ValueError>']
+            try:
+                str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
+            except ValueError:
+                str_list += ['mipmapLevelBias : <ValueError>']
+            try:
+                str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['minMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['maxMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['borderColor : ' + str(self.borderColor)]
+            except ValueError:
+                str_list += ['borderColor : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def addressMode(self):
         return [CUaddress_mode(_x) for _x in list(self._ptr[0].addressMode)]
@@ -9049,66 +9651,57 @@ cdef class CUDA_TEXTURE_DESC_st:
         return CUfilter_mode(self._ptr[0].filterMode)
     @filterMode.setter
     def filterMode(self, filterMode not None : CUfilter_mode):
-        pass
         self._ptr[0].filterMode = filterMode.value
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def maxAnisotropy(self):
         return self._ptr[0].maxAnisotropy
     @maxAnisotropy.setter
     def maxAnisotropy(self, unsigned int maxAnisotropy):
-        pass
         self._ptr[0].maxAnisotropy = maxAnisotropy
     @property
     def mipmapFilterMode(self):
         return CUfilter_mode(self._ptr[0].mipmapFilterMode)
     @mipmapFilterMode.setter
     def mipmapFilterMode(self, mipmapFilterMode not None : CUfilter_mode):
-        pass
         self._ptr[0].mipmapFilterMode = mipmapFilterMode.value
     @property
     def mipmapLevelBias(self):
         return self._ptr[0].mipmapLevelBias
     @mipmapLevelBias.setter
     def mipmapLevelBias(self, float mipmapLevelBias):
-        pass
         self._ptr[0].mipmapLevelBias = mipmapLevelBias
     @property
     def minMipmapLevelClamp(self):
         return self._ptr[0].minMipmapLevelClamp
     @minMipmapLevelClamp.setter
     def minMipmapLevelClamp(self, float minMipmapLevelClamp):
-        pass
         self._ptr[0].minMipmapLevelClamp = minMipmapLevelClamp
     @property
     def maxMipmapLevelClamp(self):
         return self._ptr[0].maxMipmapLevelClamp
     @maxMipmapLevelClamp.setter
     def maxMipmapLevelClamp(self, float maxMipmapLevelClamp):
-        pass
         self._ptr[0].maxMipmapLevelClamp = maxMipmapLevelClamp
     @property
     def borderColor(self):
         return self._ptr[0].borderColor
     @borderColor.setter
     def borderColor(self, borderColor):
-        pass
         self._ptr[0].borderColor = borderColor
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
+{{if 'struct CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
 
 cdef class CUDA_RESOURCE_VIEW_DESC_st:
     """
@@ -9145,7 +9738,7 @@ cdef class CUDA_RESOURCE_VIEW_DESC_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_RESOURCE_VIEW_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_RESOURCE_VIEW_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9155,84 +9748,101 @@ cdef class CUDA_RESOURCE_VIEW_DESC_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['format : ' + str(self.format)]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
-            str_list += ['firstMipmapLevel : ' + str(self.firstMipmapLevel)]
-            str_list += ['lastMipmapLevel : ' + str(self.lastMipmapLevel)]
-            str_list += ['firstLayer : ' + str(self.firstLayer)]
-            str_list += ['lastLayer : ' + str(self.lastLayer)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['format : ' + str(self.format)]
+            except ValueError:
+                str_list += ['format : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
+            try:
+                str_list += ['firstMipmapLevel : ' + str(self.firstMipmapLevel)]
+            except ValueError:
+                str_list += ['firstMipmapLevel : <ValueError>']
+            try:
+                str_list += ['lastMipmapLevel : ' + str(self.lastMipmapLevel)]
+            except ValueError:
+                str_list += ['lastMipmapLevel : <ValueError>']
+            try:
+                str_list += ['firstLayer : ' + str(self.firstLayer)]
+            except ValueError:
+                str_list += ['firstLayer : <ValueError>']
+            try:
+                str_list += ['lastLayer : ' + str(self.lastLayer)]
+            except ValueError:
+                str_list += ['lastLayer : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def format(self):
         return CUresourceViewFormat(self._ptr[0].format)
     @format.setter
     def format(self, format not None : CUresourceViewFormat):
-        pass
         self._ptr[0].format = format.value
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].height = height
     @property
     def depth(self):
         return self._ptr[0].depth
     @depth.setter
     def depth(self, size_t depth):
-        pass
         self._ptr[0].depth = depth
     @property
     def firstMipmapLevel(self):
         return self._ptr[0].firstMipmapLevel
     @firstMipmapLevel.setter
     def firstMipmapLevel(self, unsigned int firstMipmapLevel):
-        pass
         self._ptr[0].firstMipmapLevel = firstMipmapLevel
     @property
     def lastMipmapLevel(self):
         return self._ptr[0].lastMipmapLevel
     @lastMipmapLevel.setter
     def lastMipmapLevel(self, unsigned int lastMipmapLevel):
-        pass
         self._ptr[0].lastMipmapLevel = lastMipmapLevel
     @property
     def firstLayer(self):
         return self._ptr[0].firstLayer
     @firstLayer.setter
     def firstLayer(self, unsigned int firstLayer):
-        pass
         self._ptr[0].firstLayer = firstLayer
     @property
     def lastLayer(self):
         return self._ptr[0].lastLayer
     @lastLayer.setter
     def lastLayer(self, unsigned int lastLayer):
-        pass
         self._ptr[0].lastLayer = lastLayer
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
+{{if 'struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
 
 cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
     """
@@ -9255,7 +9865,7 @@ cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st *>_ptr
+            self._ptr = <cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9265,28 +9875,31 @@ cdef class CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['p2pToken : ' + str(self.p2pToken)]
-            str_list += ['vaSpaceToken : ' + str(self.vaSpaceToken)]
+            try:
+                str_list += ['p2pToken : ' + str(self.p2pToken)]
+            except ValueError:
+                str_list += ['p2pToken : <ValueError>']
+            try:
+                str_list += ['vaSpaceToken : ' + str(self.vaSpaceToken)]
+            except ValueError:
+                str_list += ['vaSpaceToken : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def p2pToken(self):
         return self._ptr[0].p2pToken
     @p2pToken.setter
     def p2pToken(self, unsigned long long p2pToken):
-        pass
         self._ptr[0].p2pToken = p2pToken
     @property
     def vaSpaceToken(self):
         return self._ptr[0].vaSpaceToken
     @vaSpaceToken.setter
     def vaSpaceToken(self, unsigned int vaSpaceToken):
-        pass
         self._ptr[0].vaSpaceToken = vaSpaceToken
 {{endif}}
-{{if 'CUDA_LAUNCH_PARAMS_st' in found_types}}
+{{if 'struct CUDA_LAUNCH_PARAMS_st' in found_types}}
 
 cdef class CUDA_LAUNCH_PARAMS_st:
     """
@@ -9325,7 +9938,7 @@ cdef class CUDA_LAUNCH_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_LAUNCH_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_LAUNCH_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._function = CUfunction(_ptr=<void_ptr>&self._ptr[0].function)
         self._hStream = CUstream(_ptr=<void_ptr>&self._ptr[0].hStream)
@@ -9336,117 +9949,138 @@ cdef class CUDA_LAUNCH_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['function : ' + str(self.function)]
-            str_list += ['gridDimX : ' + str(self.gridDimX)]
-            str_list += ['gridDimY : ' + str(self.gridDimY)]
-            str_list += ['gridDimZ : ' + str(self.gridDimZ)]
-            str_list += ['blockDimX : ' + str(self.blockDimX)]
-            str_list += ['blockDimY : ' + str(self.blockDimY)]
-            str_list += ['blockDimZ : ' + str(self.blockDimZ)]
-            str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
-            str_list += ['hStream : ' + str(self.hStream)]
-            str_list += ['kernelParams : ' + str(self.kernelParams)]
+            try:
+                str_list += ['function : ' + str(self.function)]
+            except ValueError:
+                str_list += ['function : <ValueError>']
+            try:
+                str_list += ['gridDimX : ' + str(self.gridDimX)]
+            except ValueError:
+                str_list += ['gridDimX : <ValueError>']
+            try:
+                str_list += ['gridDimY : ' + str(self.gridDimY)]
+            except ValueError:
+                str_list += ['gridDimY : <ValueError>']
+            try:
+                str_list += ['gridDimZ : ' + str(self.gridDimZ)]
+            except ValueError:
+                str_list += ['gridDimZ : <ValueError>']
+            try:
+                str_list += ['blockDimX : ' + str(self.blockDimX)]
+            except ValueError:
+                str_list += ['blockDimX : <ValueError>']
+            try:
+                str_list += ['blockDimY : ' + str(self.blockDimY)]
+            except ValueError:
+                str_list += ['blockDimY : <ValueError>']
+            try:
+                str_list += ['blockDimZ : ' + str(self.blockDimZ)]
+            except ValueError:
+                str_list += ['blockDimZ : <ValueError>']
+            try:
+                str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
+            except ValueError:
+                str_list += ['sharedMemBytes : <ValueError>']
+            try:
+                str_list += ['hStream : ' + str(self.hStream)]
+            except ValueError:
+                str_list += ['hStream : <ValueError>']
+            try:
+                str_list += ['kernelParams : ' + str(self.kernelParams)]
+            except ValueError:
+                str_list += ['kernelParams : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def function(self):
         return self._function
     @function.setter
     def function(self, function):
-        cdef ccuda.CUfunction cfunction
+        cdef cydriver.CUfunction cyfunction
         if function is None:
-            cfunction = <ccuda.CUfunction><void_ptr>0
-        elif isinstance(function, (CUfunction)):
+            cyfunction = <cydriver.CUfunction><void_ptr>0
+        elif isinstance(function, (CUfunction,)):
             pfunction = int(function)
-            cfunction = <ccuda.CUfunction><void_ptr>pfunction
+            cyfunction = <cydriver.CUfunction><void_ptr>pfunction
         else:
             pfunction = int(CUfunction(function))
-            cfunction = <ccuda.CUfunction><void_ptr>pfunction
-        self._function._ptr[0] = cfunction
+            cyfunction = <cydriver.CUfunction><void_ptr>pfunction
+        self._function._ptr[0] = cyfunction
     @property
     def gridDimX(self):
         return self._ptr[0].gridDimX
     @gridDimX.setter
     def gridDimX(self, unsigned int gridDimX):
-        pass
         self._ptr[0].gridDimX = gridDimX
     @property
     def gridDimY(self):
         return self._ptr[0].gridDimY
     @gridDimY.setter
     def gridDimY(self, unsigned int gridDimY):
-        pass
         self._ptr[0].gridDimY = gridDimY
     @property
     def gridDimZ(self):
         return self._ptr[0].gridDimZ
     @gridDimZ.setter
     def gridDimZ(self, unsigned int gridDimZ):
-        pass
         self._ptr[0].gridDimZ = gridDimZ
     @property
     def blockDimX(self):
         return self._ptr[0].blockDimX
     @blockDimX.setter
     def blockDimX(self, unsigned int blockDimX):
-        pass
         self._ptr[0].blockDimX = blockDimX
     @property
     def blockDimY(self):
         return self._ptr[0].blockDimY
     @blockDimY.setter
     def blockDimY(self, unsigned int blockDimY):
-        pass
         self._ptr[0].blockDimY = blockDimY
     @property
     def blockDimZ(self):
         return self._ptr[0].blockDimZ
     @blockDimZ.setter
     def blockDimZ(self, unsigned int blockDimZ):
-        pass
         self._ptr[0].blockDimZ = blockDimZ
     @property
     def sharedMemBytes(self):
         return self._ptr[0].sharedMemBytes
     @sharedMemBytes.setter
     def sharedMemBytes(self, unsigned int sharedMemBytes):
-        pass
         self._ptr[0].sharedMemBytes = sharedMemBytes
     @property
     def hStream(self):
         return self._hStream
     @hStream.setter
     def hStream(self, hStream):
-        cdef ccuda.CUstream chStream
+        cdef cydriver.CUstream cyhStream
         if hStream is None:
-            chStream = <ccuda.CUstream><void_ptr>0
-        elif isinstance(hStream, (CUstream)):
+            cyhStream = <cydriver.CUstream><void_ptr>0
+        elif isinstance(hStream, (CUstream,)):
             phStream = int(hStream)
-            chStream = <ccuda.CUstream><void_ptr>phStream
+            cyhStream = <cydriver.CUstream><void_ptr>phStream
         else:
             phStream = int(CUstream(hStream))
-            chStream = <ccuda.CUstream><void_ptr>phStream
-        self._hStream._ptr[0] = chStream
+            cyhStream = <cydriver.CUstream><void_ptr>phStream
+        self._hStream._ptr[0] = cyhStream
     @property
     def kernelParams(self):
         return <void_ptr>self._ptr[0].kernelParams
     @kernelParams.setter
     def kernelParams(self, kernelParams):
-        self._ckernelParams = utils.HelperKernelParams(kernelParams)
-        self._ptr[0].kernelParams = <void**><void_ptr>self._ckernelParams.ckernelParams
+        self._cykernelParams = utils.HelperKernelParams(kernelParams)
+        self._ptr[0].kernelParams = <void**><void_ptr>self._cykernelParams.ckernelParams
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s:
+cdef class anon_struct8:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -9456,47 +10090,54 @@ cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle.win32
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['handle : ' + hex(self.handle)]
-            str_list += ['name : ' + hex(self.name)]
+            try:
+                str_list += ['handle : ' + hex(self.handle)]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['name : ' + hex(self.name)]
+            except ValueError:
+                str_list += ['name : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def handle(self):
         return <void_ptr>self._ptr[0].handle.win32.handle
     @handle.setter
     def handle(self, handle):
-        _chandle = utils.HelperInputVoidPtr(handle)
-        self._ptr[0].handle.win32.handle = <void*><void_ptr>_chandle.cptr
+        _cyhandle = utils.HelperInputVoidPtr(handle)
+        self._ptr[0].handle.win32.handle = <void*><void_ptr>_cyhandle.cptr
     @property
     def name(self):
         return <void_ptr>self._ptr[0].handle.win32.name
     @name.setter
     def name(self, name):
-        _cname = utils.HelperInputVoidPtr(name)
-        self._ptr[0].handle.win32.name = <void*><void_ptr>_cname.cptr
+        _cyname = utils.HelperInputVoidPtr(name)
+        self._ptr[0].handle.win32.name = <void*><void_ptr>_cyname.cptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u:
+cdef class anon_union4:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s
+    win32 : anon_struct8
 
-    nvSciBufObject : void
+    nvSciBufObject : Any
 
 
     Methods
@@ -9506,48 +10147,53 @@ cdef class _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._win32 = _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s(_ptr=<void_ptr>self._ptr)
+        self._win32 = anon_struct8(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fd : ' + str(self.fd)]
-            str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
-            str_list += ['nvSciBufObject : ' + hex(self.nvSciBufObject)]
+            try:
+                str_list += ['fd : ' + str(self.fd)]
+            except ValueError:
+                str_list += ['fd : <ValueError>']
+            try:
+                str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
+            except ValueError:
+                str_list += ['win32 : <ValueError>']
+            try:
+                str_list += ['nvSciBufObject : ' + hex(self.nvSciBufObject)]
+            except ValueError:
+                str_list += ['nvSciBufObject : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fd(self):
         return self._ptr[0].handle.fd
     @fd.setter
     def fd(self, int fd):
-        pass
         self._ptr[0].handle.fd = fd
     @property
     def win32(self):
         return self._win32
     @win32.setter
-    def win32(self, win32 not None : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_handle_win32_s):
-        pass
-        for _attr in dir(win32):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._win32, _attr, getattr(win32, _attr))
+    def win32(self, win32 not None : anon_struct8):
+        string.memcpy(&self._ptr[0].handle.win32, <cydriver.anon_struct8*><void_ptr>win32.getPtr(), sizeof(self._ptr[0].handle.win32))
     @property
     def nvSciBufObject(self):
         return <void_ptr>self._ptr[0].handle.nvSciBufObject
     @nvSciBufObject.setter
     def nvSciBufObject(self, nvSciBufObject):
-        _cnvSciBufObject = utils.HelperInputVoidPtr(nvSciBufObject)
-        self._ptr[0].handle.nvSciBufObject = <void*><void_ptr>_cnvSciBufObject.cptr
+        _cynvSciBufObject = utils.HelperInputVoidPtr(nvSciBufObject)
+        self._ptr[0].handle.nvSciBufObject = <void*><void_ptr>_cynvSciBufObject.cptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     """
@@ -9557,7 +10203,7 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     ----------
     type : CUexternalMemoryHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u
+    handle : anon_union4
 
     size : unsigned long long
         Size of the memory allocation
@@ -9574,68 +10220,75 @@ cdef class CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>calloc(1, sizeof(cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._handle = _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u(_ptr=<void_ptr>self._ptr)
+        self._handle = anon_union4(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return CUexternalMemoryHandleType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : CUexternalMemoryHandleType):
-        pass
         self._ptr[0].type = type.value
     @property
     def handle(self):
         return self._handle
     @handle.setter
-    def handle(self, handle not None : _CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1_CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st_handle_u):
-        pass
-        for _attr in dir(handle):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._handle, _attr, getattr(handle, _attr))
+    def handle(self, handle not None : anon_union4):
+        string.memcpy(&self._ptr[0].handle, <cydriver.anon_union4*><void_ptr>handle.getPtr(), sizeof(self._ptr[0].handle))
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, unsigned long long size):
-        pass
         self._ptr[0].size = size
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
     """
@@ -9662,7 +10315,7 @@ cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9672,44 +10325,51 @@ cdef class CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def offset(self):
         return self._ptr[0].offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].offset = offset
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, unsigned long long size):
-        pass
         self._ptr[0].size = size
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
     """
@@ -9737,7 +10397,7 @@ cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._arrayDesc = CUDA_ARRAY3D_DESCRIPTOR(_ptr=<void_ptr>&self._ptr[0].arrayDesc)
     def __dealloc__(self):
@@ -9747,57 +10407,59 @@ cdef class CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['arrayDesc :\n' + '\n'.join(['    ' + line for line in str(self.arrayDesc).splitlines()])]
-            str_list += ['numLevels : ' + str(self.numLevels)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['arrayDesc :\n' + '\n'.join(['    ' + line for line in str(self.arrayDesc).splitlines()])]
+            except ValueError:
+                str_list += ['arrayDesc : <ValueError>']
+            try:
+                str_list += ['numLevels : ' + str(self.numLevels)]
+            except ValueError:
+                str_list += ['numLevels : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def offset(self):
         return self._ptr[0].offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].offset = offset
     @property
     def arrayDesc(self):
         return self._arrayDesc
     @arrayDesc.setter
     def arrayDesc(self, arrayDesc not None : CUDA_ARRAY3D_DESCRIPTOR):
-        pass
-        for _attr in dir(arrayDesc):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._arrayDesc, _attr, getattr(arrayDesc, _attr))
+        string.memcpy(&self._ptr[0].arrayDesc, <cydriver.CUDA_ARRAY3D_DESCRIPTOR*><void_ptr>arrayDesc.getPtr(), sizeof(self._ptr[0].arrayDesc))
     @property
     def numLevels(self):
         return self._ptr[0].numLevels
     @numLevels.setter
     def numLevels(self, unsigned int numLevels):
-        pass
         self._ptr[0].numLevels = numLevels
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s:
+cdef class anon_struct9:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -9807,47 +10469,54 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDL
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle.win32
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['handle : ' + hex(self.handle)]
-            str_list += ['name : ' + hex(self.name)]
+            try:
+                str_list += ['handle : ' + hex(self.handle)]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['name : ' + hex(self.name)]
+            except ValueError:
+                str_list += ['name : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def handle(self):
         return <void_ptr>self._ptr[0].handle.win32.handle
     @handle.setter
     def handle(self, handle):
-        _chandle = utils.HelperInputVoidPtr(handle)
-        self._ptr[0].handle.win32.handle = <void*><void_ptr>_chandle.cptr
+        _cyhandle = utils.HelperInputVoidPtr(handle)
+        self._ptr[0].handle.win32.handle = <void*><void_ptr>_cyhandle.cptr
     @property
     def name(self):
         return <void_ptr>self._ptr[0].handle.win32.name
     @name.setter
     def name(self, name):
-        _cname = utils.HelperInputVoidPtr(name)
-        self._ptr[0].handle.win32.name = <void*><void_ptr>_cname.cptr
+        _cyname = utils.HelperInputVoidPtr(name)
+        self._ptr[0].handle.win32.name = <void*><void_ptr>_cyname.cptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u:
+cdef class anon_union5:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s
+    win32 : anon_struct9
 
-    nvSciSyncObj : void
+    nvSciSyncObj : Any
 
 
     Methods
@@ -9857,48 +10526,53 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDL
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._win32 = _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s(_ptr=<void_ptr>self._ptr)
+        self._win32 = anon_struct9(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fd : ' + str(self.fd)]
-            str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
-            str_list += ['nvSciSyncObj : ' + hex(self.nvSciSyncObj)]
+            try:
+                str_list += ['fd : ' + str(self.fd)]
+            except ValueError:
+                str_list += ['fd : <ValueError>']
+            try:
+                str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
+            except ValueError:
+                str_list += ['win32 : <ValueError>']
+            try:
+                str_list += ['nvSciSyncObj : ' + hex(self.nvSciSyncObj)]
+            except ValueError:
+                str_list += ['nvSciSyncObj : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fd(self):
         return self._ptr[0].handle.fd
     @fd.setter
     def fd(self, int fd):
-        pass
         self._ptr[0].handle.fd = fd
     @property
     def win32(self):
         return self._win32
     @win32.setter
-    def win32(self, win32 not None : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_handle_win32_s):
-        pass
-        for _attr in dir(win32):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._win32, _attr, getattr(win32, _attr))
+    def win32(self, win32 not None : anon_struct9):
+        string.memcpy(&self._ptr[0].handle.win32, <cydriver.anon_struct9*><void_ptr>win32.getPtr(), sizeof(self._ptr[0].handle.win32))
     @property
     def nvSciSyncObj(self):
         return <void_ptr>self._ptr[0].handle.nvSciSyncObj
     @nvSciSyncObj.setter
     def nvSciSyncObj(self, nvSciSyncObj):
-        _cnvSciSyncObj = utils.HelperInputVoidPtr(nvSciSyncObj)
-        self._ptr[0].handle.nvSciSyncObj = <void*><void_ptr>_cnvSciSyncObj.cptr
+        _cynvSciSyncObj = utils.HelperInputVoidPtr(nvSciSyncObj)
+        self._ptr[0].handle.nvSciSyncObj = <void*><void_ptr>_cynvSciSyncObj.cptr
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     """
@@ -9908,7 +10582,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     ----------
     type : CUexternalSemaphoreHandleType
         Type of the handle
-    handle : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u
+    handle : anon_union5
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -9923,64 +10597,68 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>calloc(1, sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._handle = _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u(_ptr=<void_ptr>self._ptr)
+        self._handle = anon_union5(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return CUexternalSemaphoreHandleType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : CUexternalSemaphoreHandleType):
-        pass
         self._ptr[0].type = type.value
     @property
     def handle(self):
         return self._handle
     @handle.setter
-    def handle(self, handle not None : _CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1_CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st_handle_u):
-        pass
-        for _attr in dir(handle):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._handle, _attr, getattr(handle, _attr))
+    def handle(self, handle not None : anon_union5):
+        string.memcpy(&self._ptr[0].handle, <cydriver.anon_union5*><void_ptr>handle.getPtr(), sizeof(self._ptr[0].handle))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s:
+cdef class anon_struct10:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -9993,35 +10671,38 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.fence
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['value : ' + str(self.value)]
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def value(self):
         return self._ptr[0].params.fence.value
     @value.setter
     def value(self, unsigned long long value):
-        pass
         self._ptr[0].params.fence.value = value
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u:
+cdef class anon_union6:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -10033,40 +10714,46 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.nvSciSync
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence : ' + hex(self.fence)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence : ' + hex(self.fence)]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return <void_ptr>self._ptr[0].params.nvSciSync.fence
     @fence.setter
     def fence(self, fence):
-        _cfence = utils.HelperInputVoidPtr(fence)
-        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cfence.cptr
+        _cyfence = utils.HelperInputVoidPtr(fence)
+        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cyfence.cptr
     @property
     def reserved(self):
         return self._ptr[0].params.nvSciSync.reserved
     @reserved.setter
     def reserved(self, unsigned long long reserved):
-        pass
         self._ptr[0].params.nvSciSync.reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s:
+cdef class anon_struct11:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -10079,39 +10766,42 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.keyedMutex
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['key : ' + str(self.key)]
+            try:
+                str_list += ['key : ' + str(self.key)]
+            except ValueError:
+                str_list += ['key : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def key(self):
         return self._ptr[0].params.keyedMutex.key
     @key.setter
     def key(self, unsigned long long key):
-        pass
         self._ptr[0].params.keyedMutex.key = key
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s:
+cdef class anon_struct12:
     """
-
     Attributes
     ----------
-    fence : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s
+    fence : anon_struct10
 
-    nvSciSync : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u
+    nvSciSync : anon_union6
 
-    keyedMutex : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s
+    keyedMutex : anon_struct11
 
     reserved : List[unsigned int]
 
@@ -10123,66 +10813,64 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIG
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._fence = _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s(_ptr=<void_ptr>self._ptr)
-        self._nvSciSync = _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u(_ptr=<void_ptr>self._ptr)
-        self._keyedMutex = _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s(_ptr=<void_ptr>self._ptr)
+        self._fence = anon_struct10(_ptr=<void_ptr>self._ptr)
+        self._nvSciSync = anon_union6(_ptr=<void_ptr>self._ptr)
+        self._keyedMutex = anon_struct11(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
-            str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
-            str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
+            except ValueError:
+                str_list += ['nvSciSync : <ValueError>']
+            try:
+                str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
+            except ValueError:
+                str_list += ['keyedMutex : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return self._fence
     @fence.setter
-    def fence(self, fence not None : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_fence_s):
-        pass
-        for _attr in dir(fence):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._fence, _attr, getattr(fence, _attr))
+    def fence(self, fence not None : anon_struct10):
+        string.memcpy(&self._ptr[0].params.fence, <cydriver.anon_struct10*><void_ptr>fence.getPtr(), sizeof(self._ptr[0].params.fence))
     @property
     def nvSciSync(self):
         return self._nvSciSync
     @nvSciSync.setter
-    def nvSciSync(self, nvSciSync not None : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_nvSciSync_u):
-        pass
-        for _attr in dir(nvSciSync):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._nvSciSync, _attr, getattr(nvSciSync, _attr))
+    def nvSciSync(self, nvSciSync not None : anon_union6):
+        string.memcpy(&self._ptr[0].params.nvSciSync, <cydriver.anon_union6*><void_ptr>nvSciSync.getPtr(), sizeof(self._ptr[0].params.nvSciSync))
     @property
     def keyedMutex(self):
         return self._keyedMutex
     @keyedMutex.setter
-    def keyedMutex(self, keyedMutex not None : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_params_keyedMutex_s):
-        pass
-        for _attr in dir(keyedMutex):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._keyedMutex, _attr, getattr(keyedMutex, _attr))
+    def keyedMutex(self, keyedMutex not None : anon_struct11):
+        string.memcpy(&self._ptr[0].params.keyedMutex, <cydriver.anon_struct11*><void_ptr>keyedMutex.getPtr(), sizeof(self._ptr[0].params.keyedMutex))
     @property
     def reserved(self):
         return self._ptr[0].params.reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].params.reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
     """
@@ -10190,7 +10878,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s
+    params : anon_struct12
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS is used to signal
@@ -10214,9 +10902,9 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._params = _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s(_ptr=<void_ptr>self._ptr)
+        self._params = anon_struct12(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -10224,44 +10912,44 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
+            except ValueError:
+                str_list += ['params : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def params(self):
         return self._params
     @params.setter
-    def params(self, params not None : _CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st_params_s):
-        pass
-        for _attr in dir(params):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._params, _attr, getattr(params, _attr))
+    def params(self, params not None : anon_struct12):
+        string.memcpy(&self._ptr[0].params, <cydriver.anon_struct12*><void_ptr>params.getPtr(), sizeof(self._ptr[0].params))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s:
+cdef class anon_struct13:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -10274,35 +10962,38 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.fence
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['value : ' + str(self.value)]
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def value(self):
         return self._ptr[0].params.fence.value
     @value.setter
     def value(self, unsigned long long value):
-        pass
         self._ptr[0].params.fence.value = value
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u:
+cdef class anon_union7:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -10314,40 +11005,46 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.nvSciSync
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence : ' + hex(self.fence)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence : ' + hex(self.fence)]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return <void_ptr>self._ptr[0].params.nvSciSync.fence
     @fence.setter
     def fence(self, fence):
-        _cfence = utils.HelperInputVoidPtr(fence)
-        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cfence.cptr
+        _cyfence = utils.HelperInputVoidPtr(fence)
+        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cyfence.cptr
     @property
     def reserved(self):
         return self._ptr[0].params.nvSciSync.reserved
     @reserved.setter
     def reserved(self, unsigned long long reserved):
-        pass
         self._ptr[0].params.nvSciSync.reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s:
+cdef class anon_struct14:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -10362,47 +11059,52 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.keyedMutex
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['key : ' + str(self.key)]
-            str_list += ['timeoutMs : ' + str(self.timeoutMs)]
+            try:
+                str_list += ['key : ' + str(self.key)]
+            except ValueError:
+                str_list += ['key : <ValueError>']
+            try:
+                str_list += ['timeoutMs : ' + str(self.timeoutMs)]
+            except ValueError:
+                str_list += ['timeoutMs : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def key(self):
         return self._ptr[0].params.keyedMutex.key
     @key.setter
     def key(self, unsigned long long key):
-        pass
         self._ptr[0].params.keyedMutex.key = key
     @property
     def timeoutMs(self):
         return self._ptr[0].params.keyedMutex.timeoutMs
     @timeoutMs.setter
     def timeoutMs(self, unsigned int timeoutMs):
-        pass
         self._ptr[0].params.keyedMutex.timeoutMs = timeoutMs
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
-cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s:
+cdef class anon_struct15:
     """
-
     Attributes
     ----------
-    fence : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s
+    fence : anon_struct13
 
-    nvSciSync : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u
+    nvSciSync : anon_union7
 
-    keyedMutex : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s
+    keyedMutex : anon_struct14
 
     reserved : List[unsigned int]
 
@@ -10414,66 +11116,64 @@ cdef class _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+        self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._fence = _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s(_ptr=<void_ptr>self._ptr)
-        self._nvSciSync = _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u(_ptr=<void_ptr>self._ptr)
-        self._keyedMutex = _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s(_ptr=<void_ptr>self._ptr)
+        self._fence = anon_struct13(_ptr=<void_ptr>self._ptr)
+        self._nvSciSync = anon_union7(_ptr=<void_ptr>self._ptr)
+        self._keyedMutex = anon_struct14(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
-            str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
-            str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
+            except ValueError:
+                str_list += ['nvSciSync : <ValueError>']
+            try:
+                str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
+            except ValueError:
+                str_list += ['keyedMutex : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return self._fence
     @fence.setter
-    def fence(self, fence not None : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_fence_s):
-        pass
-        for _attr in dir(fence):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._fence, _attr, getattr(fence, _attr))
+    def fence(self, fence not None : anon_struct13):
+        string.memcpy(&self._ptr[0].params.fence, <cydriver.anon_struct13*><void_ptr>fence.getPtr(), sizeof(self._ptr[0].params.fence))
     @property
     def nvSciSync(self):
         return self._nvSciSync
     @nvSciSync.setter
-    def nvSciSync(self, nvSciSync not None : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_nvSciSync_u):
-        pass
-        for _attr in dir(nvSciSync):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._nvSciSync, _attr, getattr(nvSciSync, _attr))
+    def nvSciSync(self, nvSciSync not None : anon_union7):
+        string.memcpy(&self._ptr[0].params.nvSciSync, <cydriver.anon_union7*><void_ptr>nvSciSync.getPtr(), sizeof(self._ptr[0].params.nvSciSync))
     @property
     def keyedMutex(self):
         return self._keyedMutex
     @keyedMutex.setter
-    def keyedMutex(self, keyedMutex not None : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_params_keyedMutex_s):
-        pass
-        for _attr in dir(keyedMutex):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._keyedMutex, _attr, getattr(keyedMutex, _attr))
+    def keyedMutex(self, keyedMutex not None : anon_struct14):
+        string.memcpy(&self._ptr[0].params.keyedMutex, <cydriver.anon_struct14*><void_ptr>keyedMutex.getPtr(), sizeof(self._ptr[0].params.keyedMutex))
     @property
     def reserved(self):
         return self._ptr[0].params.reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].params.reserved = reserved
 {{endif}}
-{{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
     """
@@ -10481,7 +11181,7 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
 
     Attributes
     ----------
-    params : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS is used to wait on
@@ -10505,9 +11205,9 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._params = _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s(_ptr=<void_ptr>self._ptr)
+        self._params = anon_struct15(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -10515,40 +11215,41 @@ cdef class CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
+            except ValueError:
+                str_list += ['params : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def params(self):
         return self._params
     @params.setter
-    def params(self, params not None : _CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1_CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st_params_s):
-        pass
-        for _attr in dir(params):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._params, _attr, getattr(params, _attr))
+    def params(self, params not None : anon_struct15):
+        string.memcpy(&self._ptr[0].params, <cydriver.anon_struct15*><void_ptr>params.getPtr(), sizeof(self._ptr[0].params))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
     """
@@ -10574,7 +11275,7 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -10587,16 +11288,24 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['extSemArray : ' + str(self.extSemArray)]
-            str_list += ['paramsArray : ' + str(self.paramsArray)]
-            str_list += ['numExtSems : ' + str(self.numExtSems)]
+            try:
+                str_list += ['extSemArray : ' + str(self.extSemArray)]
+            except ValueError:
+                str_list += ['extSemArray : <ValueError>']
+            try:
+                str_list += ['paramsArray : ' + str(self.paramsArray)]
+            except ValueError:
+                str_list += ['paramsArray : <ValueError>']
+            try:
+                str_list += ['numExtSems : ' + str(self.numExtSems)]
+            except ValueError:
+                str_list += ['numExtSems : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def extSemArray(self):
-        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(ccuda.CUexternalSemaphore) for x in range(self._extSemArray_length)]
+        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(cydriver.CUexternalSemaphore) for x in range(self._extSemArray_length)]
         return [CUexternalSemaphore(_ptr=arr) for arr in arrs]
     @extSemArray.setter
     def extSemArray(self, val):
@@ -10607,16 +11316,17 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
         else:
             if self._extSemArray_length != <size_t>len(val):
                 free(self._extSemArray)
-                self._extSemArray = <ccuda.CUexternalSemaphore*> calloc(len(val), sizeof(ccuda.CUexternalSemaphore))
+                self._extSemArray = <cydriver.CUexternalSemaphore*> calloc(len(val), sizeof(cydriver.CUexternalSemaphore))
                 if self._extSemArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUexternalSemaphore)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUexternalSemaphore)))
                 self._extSemArray_length = <size_t>len(val)
                 self._ptr[0].extSemArray = self._extSemArray
             for idx in range(len(val)):
                 self._extSemArray[idx] = (<CUexternalSemaphore>val[idx])._ptr[0]
+
     @property
     def paramsArray(self):
-        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS) for x in range(self._paramsArray_length)]
+        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS) for x in range(self._paramsArray_length)]
         return [CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS(_ptr=arr) for arr in arrs]
     @paramsArray.setter
     def paramsArray(self, val):
@@ -10627,22 +11337,22 @@ cdef class CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
         else:
             if self._paramsArray_length != <size_t>len(val):
                 free(self._paramsArray)
-                self._paramsArray = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*> calloc(len(val), sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
+                self._paramsArray = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*> calloc(len(val), sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
                 if self._paramsArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS)))
                 self._paramsArray_length = <size_t>len(val)
                 self._ptr[0].paramsArray = self._paramsArray
             for idx in range(len(val)):
-                memcpy(&self._paramsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>val[idx])._ptr, sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
+                string.memcpy(&self._paramsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>val[idx])._ptr, sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
+
     @property
     def numExtSems(self):
         return self._ptr[0].numExtSems
     @numExtSems.setter
     def numExtSems(self, unsigned int numExtSems):
-        pass
         self._ptr[0].numExtSems = numExtSems
 {{endif}}
-{{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
     """
@@ -10668,7 +11378,7 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -10681,16 +11391,24 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['extSemArray : ' + str(self.extSemArray)]
-            str_list += ['paramsArray : ' + str(self.paramsArray)]
-            str_list += ['numExtSems : ' + str(self.numExtSems)]
+            try:
+                str_list += ['extSemArray : ' + str(self.extSemArray)]
+            except ValueError:
+                str_list += ['extSemArray : <ValueError>']
+            try:
+                str_list += ['paramsArray : ' + str(self.paramsArray)]
+            except ValueError:
+                str_list += ['paramsArray : <ValueError>']
+            try:
+                str_list += ['numExtSems : ' + str(self.numExtSems)]
+            except ValueError:
+                str_list += ['numExtSems : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def extSemArray(self):
-        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(ccuda.CUexternalSemaphore) for x in range(self._extSemArray_length)]
+        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(cydriver.CUexternalSemaphore) for x in range(self._extSemArray_length)]
         return [CUexternalSemaphore(_ptr=arr) for arr in arrs]
     @extSemArray.setter
     def extSemArray(self, val):
@@ -10701,16 +11419,17 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
         else:
             if self._extSemArray_length != <size_t>len(val):
                 free(self._extSemArray)
-                self._extSemArray = <ccuda.CUexternalSemaphore*> calloc(len(val), sizeof(ccuda.CUexternalSemaphore))
+                self._extSemArray = <cydriver.CUexternalSemaphore*> calloc(len(val), sizeof(cydriver.CUexternalSemaphore))
                 if self._extSemArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUexternalSemaphore)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUexternalSemaphore)))
                 self._extSemArray_length = <size_t>len(val)
                 self._ptr[0].extSemArray = self._extSemArray
             for idx in range(len(val)):
                 self._extSemArray[idx] = (<CUexternalSemaphore>val[idx])._ptr[0]
+
     @property
     def paramsArray(self):
-        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS) for x in range(self._paramsArray_length)]
+        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS) for x in range(self._paramsArray_length)]
         return [CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS(_ptr=arr) for arr in arrs]
     @paramsArray.setter
     def paramsArray(self, val):
@@ -10721,26 +11440,25 @@ cdef class CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
         else:
             if self._paramsArray_length != <size_t>len(val):
                 free(self._paramsArray)
-                self._paramsArray = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*> calloc(len(val), sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
+                self._paramsArray = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*> calloc(len(val), sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
                 if self._paramsArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS)))
                 self._paramsArray_length = <size_t>len(val)
                 self._ptr[0].paramsArray = self._paramsArray
             for idx in range(len(val)):
-                memcpy(&self._paramsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>val[idx])._ptr, sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
+                string.memcpy(&self._paramsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>val[idx])._ptr, sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
+
     @property
     def numExtSems(self):
         return self._ptr[0].numExtSems
     @numExtSems.setter
     def numExtSems(self, unsigned int numExtSems):
-        pass
         self._ptr[0].numExtSems = numExtSems
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u:
+cdef class anon_union8:
     """
-
     Attributes
     ----------
     mipmap : CUmipmappedArray
@@ -10755,57 +11473,64 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+        self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._mipmap = CUmipmappedArray(_ptr=<void_ptr>&self._ptr[0].resource.mipmap)
         self._array = CUarray(_ptr=<void_ptr>&self._ptr[0].resource.array)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].resource
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['mipmap : ' + str(self.mipmap)]
-            str_list += ['array : ' + str(self.array)]
+            try:
+                str_list += ['mipmap : ' + str(self.mipmap)]
+            except ValueError:
+                str_list += ['mipmap : <ValueError>']
+            try:
+                str_list += ['array : ' + str(self.array)]
+            except ValueError:
+                str_list += ['array : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def mipmap(self):
         return self._mipmap
     @mipmap.setter
     def mipmap(self, mipmap):
-        cdef ccuda.CUmipmappedArray cmipmap
+        cdef cydriver.CUmipmappedArray cymipmap
         if mipmap is None:
-            cmipmap = <ccuda.CUmipmappedArray><void_ptr>0
-        elif isinstance(mipmap, (CUmipmappedArray)):
+            cymipmap = <cydriver.CUmipmappedArray><void_ptr>0
+        elif isinstance(mipmap, (CUmipmappedArray,)):
             pmipmap = int(mipmap)
-            cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
+            cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
         else:
             pmipmap = int(CUmipmappedArray(mipmap))
-            cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
-        self._mipmap._ptr[0] = cmipmap
+            cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
+        self._mipmap._ptr[0] = cymipmap
     @property
     def array(self):
         return self._array
     @array.setter
     def array(self, array):
-        cdef ccuda.CUarray carray
+        cdef cydriver.CUarray cyarray
         if array is None:
-            carray = <ccuda.CUarray><void_ptr>0
-        elif isinstance(array, (CUarray)):
+            cyarray = <cydriver.CUarray><void_ptr>0
+        elif isinstance(array, (CUarray,)):
             parray = int(array)
-            carray = <ccuda.CUarray><void_ptr>parray
+            cyarray = <cydriver.CUarray><void_ptr>parray
         else:
             parray = int(CUarray(array))
-            carray = <ccuda.CUarray><void_ptr>parray
-        self._array._ptr[0] = carray
+            cyarray = <cydriver.CUarray><void_ptr>parray
+        self._array._ptr[0] = cyarray
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s:
+cdef class anon_struct16:
     """
-
     Attributes
     ----------
     level : unsigned int
@@ -10832,88 +11557,105 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_su
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+        self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].subresource.sparseLevel
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['level : ' + str(self.level)]
-            str_list += ['layer : ' + str(self.layer)]
-            str_list += ['offsetX : ' + str(self.offsetX)]
-            str_list += ['offsetY : ' + str(self.offsetY)]
-            str_list += ['offsetZ : ' + str(self.offsetZ)]
-            str_list += ['extentWidth : ' + str(self.extentWidth)]
-            str_list += ['extentHeight : ' + str(self.extentHeight)]
-            str_list += ['extentDepth : ' + str(self.extentDepth)]
+            try:
+                str_list += ['level : ' + str(self.level)]
+            except ValueError:
+                str_list += ['level : <ValueError>']
+            try:
+                str_list += ['layer : ' + str(self.layer)]
+            except ValueError:
+                str_list += ['layer : <ValueError>']
+            try:
+                str_list += ['offsetX : ' + str(self.offsetX)]
+            except ValueError:
+                str_list += ['offsetX : <ValueError>']
+            try:
+                str_list += ['offsetY : ' + str(self.offsetY)]
+            except ValueError:
+                str_list += ['offsetY : <ValueError>']
+            try:
+                str_list += ['offsetZ : ' + str(self.offsetZ)]
+            except ValueError:
+                str_list += ['offsetZ : <ValueError>']
+            try:
+                str_list += ['extentWidth : ' + str(self.extentWidth)]
+            except ValueError:
+                str_list += ['extentWidth : <ValueError>']
+            try:
+                str_list += ['extentHeight : ' + str(self.extentHeight)]
+            except ValueError:
+                str_list += ['extentHeight : <ValueError>']
+            try:
+                str_list += ['extentDepth : ' + str(self.extentDepth)]
+            except ValueError:
+                str_list += ['extentDepth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def level(self):
         return self._ptr[0].subresource.sparseLevel.level
     @level.setter
     def level(self, unsigned int level):
-        pass
         self._ptr[0].subresource.sparseLevel.level = level
     @property
     def layer(self):
         return self._ptr[0].subresource.sparseLevel.layer
     @layer.setter
     def layer(self, unsigned int layer):
-        pass
         self._ptr[0].subresource.sparseLevel.layer = layer
     @property
     def offsetX(self):
         return self._ptr[0].subresource.sparseLevel.offsetX
     @offsetX.setter
     def offsetX(self, unsigned int offsetX):
-        pass
         self._ptr[0].subresource.sparseLevel.offsetX = offsetX
     @property
     def offsetY(self):
         return self._ptr[0].subresource.sparseLevel.offsetY
     @offsetY.setter
     def offsetY(self, unsigned int offsetY):
-        pass
         self._ptr[0].subresource.sparseLevel.offsetY = offsetY
     @property
     def offsetZ(self):
         return self._ptr[0].subresource.sparseLevel.offsetZ
     @offsetZ.setter
     def offsetZ(self, unsigned int offsetZ):
-        pass
         self._ptr[0].subresource.sparseLevel.offsetZ = offsetZ
     @property
     def extentWidth(self):
         return self._ptr[0].subresource.sparseLevel.extentWidth
     @extentWidth.setter
     def extentWidth(self, unsigned int extentWidth):
-        pass
         self._ptr[0].subresource.sparseLevel.extentWidth = extentWidth
     @property
     def extentHeight(self):
         return self._ptr[0].subresource.sparseLevel.extentHeight
     @extentHeight.setter
     def extentHeight(self, unsigned int extentHeight):
-        pass
         self._ptr[0].subresource.sparseLevel.extentHeight = extentHeight
     @property
     def extentDepth(self):
         return self._ptr[0].subresource.sparseLevel.extentDepth
     @extentDepth.setter
     def extentDepth(self, unsigned int extentDepth):
-        pass
         self._ptr[0].subresource.sparseLevel.extentDepth = extentDepth
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s:
+cdef class anon_struct17:
     """
-
     Attributes
     ----------
     layer : unsigned int
@@ -10930,53 +11672,60 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_su
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+        self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].subresource.miptail
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['layer : ' + str(self.layer)]
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['size : ' + str(self.size)]
+            try:
+                str_list += ['layer : ' + str(self.layer)]
+            except ValueError:
+                str_list += ['layer : <ValueError>']
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def layer(self):
         return self._ptr[0].subresource.miptail.layer
     @layer.setter
     def layer(self, unsigned int layer):
-        pass
         self._ptr[0].subresource.miptail.layer = layer
     @property
     def offset(self):
         return self._ptr[0].subresource.miptail.offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].subresource.miptail.offset = offset
     @property
     def size(self):
         return self._ptr[0].subresource.miptail.size
     @size.setter
     def size(self, unsigned long long size):
-        pass
         self._ptr[0].subresource.miptail.size = size
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u:
+cdef class anon_union9:
     """
-
     Attributes
     ----------
-    sparseLevel : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s
+    sparseLevel : anon_struct16
 
-    miptail : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s
+    miptail : anon_struct17
 
 
     Methods
@@ -10986,49 +11735,46 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+        self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._sparseLevel = _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s(_ptr=<void_ptr>self._ptr)
-        self._miptail = _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s(_ptr=<void_ptr>self._ptr)
+        self._sparseLevel = anon_struct16(_ptr=<void_ptr>self._ptr)
+        self._miptail = anon_struct17(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].subresource
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['sparseLevel :\n' + '\n'.join(['    ' + line for line in str(self.sparseLevel).splitlines()])]
-            str_list += ['miptail :\n' + '\n'.join(['    ' + line for line in str(self.miptail).splitlines()])]
+            try:
+                str_list += ['sparseLevel :\n' + '\n'.join(['    ' + line for line in str(self.sparseLevel).splitlines()])]
+            except ValueError:
+                str_list += ['sparseLevel : <ValueError>']
+            try:
+                str_list += ['miptail :\n' + '\n'.join(['    ' + line for line in str(self.miptail).splitlines()])]
+            except ValueError:
+                str_list += ['miptail : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def sparseLevel(self):
         return self._sparseLevel
     @sparseLevel.setter
-    def sparseLevel(self, sparseLevel not None : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_sparseLevel_s):
-        pass
-        for _attr in dir(sparseLevel):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._sparseLevel, _attr, getattr(sparseLevel, _attr))
+    def sparseLevel(self, sparseLevel not None : anon_struct16):
+        string.memcpy(&self._ptr[0].subresource.sparseLevel, <cydriver.anon_struct16*><void_ptr>sparseLevel.getPtr(), sizeof(self._ptr[0].subresource.sparseLevel))
     @property
     def miptail(self):
         return self._miptail
     @miptail.setter
-    def miptail(self, miptail not None : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_subresource_miptail_s):
-        pass
-        for _attr in dir(miptail):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._miptail, _attr, getattr(miptail, _attr))
+    def miptail(self, miptail not None : anon_struct17):
+        string.memcpy(&self._ptr[0].subresource.miptail, <cydriver.anon_struct17*><void_ptr>miptail.getPtr(), sizeof(self._ptr[0].subresource.miptail))
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
-cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u:
+cdef class anon_union10:
     """
-
     Attributes
     ----------
     memHandle : CUmemGenericAllocationHandle
@@ -11041,36 +11787,42 @@ cdef class _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+        self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._memHandle = CUmemGenericAllocationHandle(_ptr=<void_ptr>&self._ptr[0].memHandle.memHandle)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].memHandle
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['memHandle : ' + str(self.memHandle)]
+            try:
+                str_list += ['memHandle : ' + str(self.memHandle)]
+            except ValueError:
+                str_list += ['memHandle : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def memHandle(self):
         return self._memHandle
     @memHandle.setter
     def memHandle(self, memHandle):
-        cdef ccuda.CUmemGenericAllocationHandle cmemHandle
+        cdef cydriver.CUmemGenericAllocationHandle cymemHandle
         if memHandle is None:
-            cmemHandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>0
+            cymemHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>0
         elif isinstance(memHandle, (CUmemGenericAllocationHandle)):
             pmemHandle = int(memHandle)
-            cmemHandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>pmemHandle
+            cymemHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmemHandle
         else:
             pmemHandle = int(CUmemGenericAllocationHandle(memHandle))
-            cmemHandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>pmemHandle
-        self._memHandle._ptr[0] = cmemHandle
+            cymemHandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>pmemHandle
+        self._memHandle._ptr[0] = cymemHandle
+
 {{endif}}
-{{if 'CUarrayMapInfo_st' in found_types}}
+{{if 'struct CUarrayMapInfo_st' in found_types}}
 
 cdef class CUarrayMapInfo_st:
     """
@@ -11081,17 +11833,17 @@ cdef class CUarrayMapInfo_st:
     ----------
     resourceType : CUresourcetype
         Resource type
-    resource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u
+    resource : anon_union8
 
     subresourceType : CUarraySparseSubresourceType
         Sparse subresource type
-    subresource : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u
+    subresource : anon_union9
 
     memOperationType : CUmemOperationType
         Memory operation type
     memHandleType : CUmemHandleType
         Memory handle type
-    memHandle : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u
+    memHandle : anon_union10
 
     offset : unsigned long long
         Offset within mip tail  Offset within the memory
@@ -11110,126 +11862,137 @@ cdef class CUarrayMapInfo_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUarrayMapInfo_st *>calloc(1, sizeof(cydriver.CUarrayMapInfo_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUarrayMapInfo_st *>_ptr
+            self._ptr = <cydriver.CUarrayMapInfo_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._resource = _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u(_ptr=<void_ptr>self._ptr)
-        self._subresource = _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u(_ptr=<void_ptr>self._ptr)
-        self._memHandle = _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u(_ptr=<void_ptr>self._ptr)
+        self._resource = anon_union8(_ptr=<void_ptr>self._ptr)
+        self._subresource = anon_union9(_ptr=<void_ptr>self._ptr)
+        self._memHandle = anon_union10(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['resourceType : ' + str(self.resourceType)]
-            str_list += ['resource :\n' + '\n'.join(['    ' + line for line in str(self.resource).splitlines()])]
-            str_list += ['subresourceType : ' + str(self.subresourceType)]
-            str_list += ['subresource :\n' + '\n'.join(['    ' + line for line in str(self.subresource).splitlines()])]
-            str_list += ['memOperationType : ' + str(self.memOperationType)]
-            str_list += ['memHandleType : ' + str(self.memHandleType)]
-            str_list += ['memHandle :\n' + '\n'.join(['    ' + line for line in str(self.memHandle).splitlines()])]
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['deviceBitMask : ' + str(self.deviceBitMask)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['resourceType : ' + str(self.resourceType)]
+            except ValueError:
+                str_list += ['resourceType : <ValueError>']
+            try:
+                str_list += ['resource :\n' + '\n'.join(['    ' + line for line in str(self.resource).splitlines()])]
+            except ValueError:
+                str_list += ['resource : <ValueError>']
+            try:
+                str_list += ['subresourceType : ' + str(self.subresourceType)]
+            except ValueError:
+                str_list += ['subresourceType : <ValueError>']
+            try:
+                str_list += ['subresource :\n' + '\n'.join(['    ' + line for line in str(self.subresource).splitlines()])]
+            except ValueError:
+                str_list += ['subresource : <ValueError>']
+            try:
+                str_list += ['memOperationType : ' + str(self.memOperationType)]
+            except ValueError:
+                str_list += ['memOperationType : <ValueError>']
+            try:
+                str_list += ['memHandleType : ' + str(self.memHandleType)]
+            except ValueError:
+                str_list += ['memHandleType : <ValueError>']
+            try:
+                str_list += ['memHandle :\n' + '\n'.join(['    ' + line for line in str(self.memHandle).splitlines()])]
+            except ValueError:
+                str_list += ['memHandle : <ValueError>']
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['deviceBitMask : ' + str(self.deviceBitMask)]
+            except ValueError:
+                str_list += ['deviceBitMask : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def resourceType(self):
         return CUresourcetype(self._ptr[0].resourceType)
     @resourceType.setter
     def resourceType(self, resourceType not None : CUresourcetype):
-        pass
         self._ptr[0].resourceType = resourceType.value
     @property
     def resource(self):
         return self._resource
     @resource.setter
-    def resource(self, resource not None : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_resource_u):
-        pass
-        for _attr in dir(resource):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._resource, _attr, getattr(resource, _attr))
+    def resource(self, resource not None : anon_union8):
+        string.memcpy(&self._ptr[0].resource, <cydriver.anon_union8*><void_ptr>resource.getPtr(), sizeof(self._ptr[0].resource))
     @property
     def subresourceType(self):
         return CUarraySparseSubresourceType(self._ptr[0].subresourceType)
     @subresourceType.setter
     def subresourceType(self, subresourceType not None : CUarraySparseSubresourceType):
-        pass
         self._ptr[0].subresourceType = subresourceType.value
     @property
     def subresource(self):
         return self._subresource
     @subresource.setter
-    def subresource(self, subresource not None : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_subresource_u):
-        pass
-        for _attr in dir(subresource):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._subresource, _attr, getattr(subresource, _attr))
+    def subresource(self, subresource not None : anon_union9):
+        string.memcpy(&self._ptr[0].subresource, <cydriver.anon_union9*><void_ptr>subresource.getPtr(), sizeof(self._ptr[0].subresource))
     @property
     def memOperationType(self):
         return CUmemOperationType(self._ptr[0].memOperationType)
     @memOperationType.setter
     def memOperationType(self, memOperationType not None : CUmemOperationType):
-        pass
         self._ptr[0].memOperationType = memOperationType.value
     @property
     def memHandleType(self):
         return CUmemHandleType(self._ptr[0].memHandleType)
     @memHandleType.setter
     def memHandleType(self, memHandleType not None : CUmemHandleType):
-        pass
         self._ptr[0].memHandleType = memHandleType.value
     @property
     def memHandle(self):
         return self._memHandle
     @memHandle.setter
-    def memHandle(self, memHandle not None : _CUarrayMapInfo_v1_CUarrayMapInfo_v1_CUarrayMapInfo_st_memHandle_u):
-        pass
-        for _attr in dir(memHandle):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._memHandle, _attr, getattr(memHandle, _attr))
+    def memHandle(self, memHandle not None : anon_union10):
+        string.memcpy(&self._ptr[0].memHandle, <cydriver.anon_union10*><void_ptr>memHandle.getPtr(), sizeof(self._ptr[0].memHandle))
     @property
     def offset(self):
         return self._ptr[0].offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].offset = offset
     @property
     def deviceBitMask(self):
         return self._ptr[0].deviceBitMask
     @deviceBitMask.setter
     def deviceBitMask(self, unsigned int deviceBitMask):
-        pass
         self._ptr[0].deviceBitMask = deviceBitMask
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'CUmemLocation_st' in found_types}}
+{{if 'struct CUmemLocation_st' in found_types}}
 
 cdef class CUmemLocation_st:
     """
@@ -11252,7 +12015,7 @@ cdef class CUmemLocation_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemLocation_st *>_ptr
+            self._ptr = <cydriver.CUmemLocation_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -11262,41 +12025,43 @@ cdef class CUmemLocation_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['id : ' + str(self.id)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['id : ' + str(self.id)]
+            except ValueError:
+                str_list += ['id : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return CUmemLocationType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : CUmemLocationType):
-        pass
         self._ptr[0].type = type.value
     @property
     def id(self):
         return self._ptr[0].id
     @id.setter
     def id(self, int id):
-        pass
         self._ptr[0].id = id
 {{endif}}
-{{if 'CUmemAllocationProp_st' in found_types}}
+{{if 'struct CUmemAllocationProp_st' in found_types}}
 
-cdef class _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s:
+cdef class anon_struct18:
     """
-
     Attributes
     ----------
-    compressionType : unsigned char
+    compressionType : bytes
 
-    gpuDirectRDMACapable : unsigned char
+    gpuDirectRDMACapable : bytes
 
     usage : unsigned short
 
-    reserved : unsigned char
+    reserved : bytes
 
 
     Methods
@@ -11306,42 +12071,53 @@ cdef class _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUmemAllocationProp_st *>_ptr
+        self._ptr = <cydriver.CUmemAllocationProp_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].allocFlags
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['compressionType : ' + str(self.compressionType)]
-            str_list += ['gpuDirectRDMACapable : ' + str(self.gpuDirectRDMACapable)]
-            str_list += ['usage : ' + str(self.usage)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['compressionType : ' + str(self.compressionType)]
+            except ValueError:
+                str_list += ['compressionType : <ValueError>']
+            try:
+                str_list += ['gpuDirectRDMACapable : ' + str(self.gpuDirectRDMACapable)]
+            except ValueError:
+                str_list += ['gpuDirectRDMACapable : <ValueError>']
+            try:
+                str_list += ['usage : ' + str(self.usage)]
+            except ValueError:
+                str_list += ['usage : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def compressionType(self):
         return self._ptr[0].allocFlags.compressionType
     @compressionType.setter
     def compressionType(self, unsigned char compressionType):
-        pass
         self._ptr[0].allocFlags.compressionType = compressionType
     @property
     def gpuDirectRDMACapable(self):
         return self._ptr[0].allocFlags.gpuDirectRDMACapable
     @gpuDirectRDMACapable.setter
     def gpuDirectRDMACapable(self, unsigned char gpuDirectRDMACapable):
-        pass
         self._ptr[0].allocFlags.gpuDirectRDMACapable = gpuDirectRDMACapable
     @property
     def usage(self):
         return self._ptr[0].allocFlags.usage
     @usage.setter
     def usage(self, unsigned short usage):
-        pass
         self._ptr[0].allocFlags.usage = usage
     @property
     def reserved(self):
@@ -11353,7 +12129,7 @@ cdef class _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st
         for i, b in enumerate(reserved):
             self._ptr[0].allocFlags.reserved[i] = b
 {{endif}}
-{{if 'CUmemAllocationProp_st' in found_types}}
+{{if 'struct CUmemAllocationProp_st' in found_types}}
 
 cdef class CUmemAllocationProp_st:
     """
@@ -11373,7 +12149,7 @@ cdef class CUmemAllocationProp_st:
         structure includes security attributes that define the scope of
         which exported allocations may be tranferred to other processes. In
         all other cases, this field is required to be zero.
-    allocFlags : _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s
+    allocFlags : anon_struct18
 
 
     Methods
@@ -11386,10 +12162,10 @@ cdef class CUmemAllocationProp_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemAllocationProp_st *>_ptr
+            self._ptr = <cydriver.CUmemAllocationProp_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._location = CUmemLocation(_ptr=<void_ptr>&self._ptr[0].location)
-        self._allocFlags = _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s(_ptr=<void_ptr>self._ptr)
+        self._allocFlags = anon_struct18(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -11397,60 +12173,62 @@ cdef class CUmemAllocationProp_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['requestedHandleTypes : ' + str(self.requestedHandleTypes)]
-            str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
-            str_list += ['win32HandleMetaData : ' + hex(self.win32HandleMetaData)]
-            str_list += ['allocFlags :\n' + '\n'.join(['    ' + line for line in str(self.allocFlags).splitlines()])]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['requestedHandleTypes : ' + str(self.requestedHandleTypes)]
+            except ValueError:
+                str_list += ['requestedHandleTypes : <ValueError>']
+            try:
+                str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
+            except ValueError:
+                str_list += ['location : <ValueError>']
+            try:
+                str_list += ['win32HandleMetaData : ' + hex(self.win32HandleMetaData)]
+            except ValueError:
+                str_list += ['win32HandleMetaData : <ValueError>']
+            try:
+                str_list += ['allocFlags :\n' + '\n'.join(['    ' + line for line in str(self.allocFlags).splitlines()])]
+            except ValueError:
+                str_list += ['allocFlags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return CUmemAllocationType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : CUmemAllocationType):
-        pass
         self._ptr[0].type = type.value
     @property
     def requestedHandleTypes(self):
         return CUmemAllocationHandleType(self._ptr[0].requestedHandleTypes)
     @requestedHandleTypes.setter
     def requestedHandleTypes(self, requestedHandleTypes not None : CUmemAllocationHandleType):
-        pass
         self._ptr[0].requestedHandleTypes = requestedHandleTypes.value
     @property
     def location(self):
         return self._location
     @location.setter
     def location(self, location not None : CUmemLocation):
-        pass
-        for _attr in dir(location):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._location, _attr, getattr(location, _attr))
+        string.memcpy(&self._ptr[0].location, <cydriver.CUmemLocation*><void_ptr>location.getPtr(), sizeof(self._ptr[0].location))
     @property
     def win32HandleMetaData(self):
         return <void_ptr>self._ptr[0].win32HandleMetaData
     @win32HandleMetaData.setter
     def win32HandleMetaData(self, win32HandleMetaData):
-        _cwin32HandleMetaData = utils.HelperInputVoidPtr(win32HandleMetaData)
-        self._ptr[0].win32HandleMetaData = <void*><void_ptr>_cwin32HandleMetaData.cptr
+        _cywin32HandleMetaData = utils.HelperInputVoidPtr(win32HandleMetaData)
+        self._ptr[0].win32HandleMetaData = <void*><void_ptr>_cywin32HandleMetaData.cptr
     @property
     def allocFlags(self):
         return self._allocFlags
     @allocFlags.setter
-    def allocFlags(self, allocFlags not None : _CUmemAllocationProp_v1_CUmemAllocationProp_v1_CUmemAllocationProp_st_allocFlags_s):
-        pass
-        for _attr in dir(allocFlags):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._allocFlags, _attr, getattr(allocFlags, _attr))
+    def allocFlags(self, allocFlags not None : anon_struct18):
+        string.memcpy(&self._ptr[0].allocFlags, <cydriver.anon_struct18*><void_ptr>allocFlags.getPtr(), sizeof(self._ptr[0].allocFlags))
 {{endif}}
-{{if 'CUmemAccessDesc_st' in found_types}}
+{{if 'struct CUmemAccessDesc_st' in found_types}}
 
 cdef class CUmemAccessDesc_st:
     """
@@ -11473,7 +12251,7 @@ cdef class CUmemAccessDesc_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemAccessDesc_st *>_ptr
+            self._ptr = <cydriver.CUmemAccessDesc_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._location = CUmemLocation(_ptr=<void_ptr>&self._ptr[0].location)
     def __dealloc__(self):
@@ -11483,32 +12261,31 @@ cdef class CUmemAccessDesc_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
+            except ValueError:
+                str_list += ['location : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def location(self):
         return self._location
     @location.setter
     def location(self, location not None : CUmemLocation):
-        pass
-        for _attr in dir(location):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._location, _attr, getattr(location, _attr))
+        string.memcpy(&self._ptr[0].location, <cydriver.CUmemLocation*><void_ptr>location.getPtr(), sizeof(self._ptr[0].location))
     @property
     def flags(self):
         return CUmemAccess_flags(self._ptr[0].flags)
     @flags.setter
     def flags(self, flags not None : CUmemAccess_flags):
-        pass
         self._ptr[0].flags = flags.value
 {{endif}}
-{{if 'CUmemPoolProps_st' in found_types}}
+{{if 'struct CUmemPoolProps_st' in found_types}}
 
 cdef class CUmemPoolProps_st:
     """
@@ -11542,7 +12319,7 @@ cdef class CUmemPoolProps_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemPoolProps_st *>_ptr
+            self._ptr = <cydriver.CUmemPoolProps_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._location = CUmemLocation(_ptr=<void_ptr>&self._ptr[0].location)
     def __dealloc__(self):
@@ -11552,47 +12329,54 @@ cdef class CUmemPoolProps_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['allocType : ' + str(self.allocType)]
-            str_list += ['handleTypes : ' + str(self.handleTypes)]
-            str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
-            str_list += ['win32SecurityAttributes : ' + hex(self.win32SecurityAttributes)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['allocType : ' + str(self.allocType)]
+            except ValueError:
+                str_list += ['allocType : <ValueError>']
+            try:
+                str_list += ['handleTypes : ' + str(self.handleTypes)]
+            except ValueError:
+                str_list += ['handleTypes : <ValueError>']
+            try:
+                str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
+            except ValueError:
+                str_list += ['location : <ValueError>']
+            try:
+                str_list += ['win32SecurityAttributes : ' + hex(self.win32SecurityAttributes)]
+            except ValueError:
+                str_list += ['win32SecurityAttributes : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def allocType(self):
         return CUmemAllocationType(self._ptr[0].allocType)
     @allocType.setter
     def allocType(self, allocType not None : CUmemAllocationType):
-        pass
         self._ptr[0].allocType = allocType.value
     @property
     def handleTypes(self):
         return CUmemAllocationHandleType(self._ptr[0].handleTypes)
     @handleTypes.setter
     def handleTypes(self, handleTypes not None : CUmemAllocationHandleType):
-        pass
         self._ptr[0].handleTypes = handleTypes.value
     @property
     def location(self):
         return self._location
     @location.setter
     def location(self, location not None : CUmemLocation):
-        pass
-        for _attr in dir(location):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._location, _attr, getattr(location, _attr))
+        string.memcpy(&self._ptr[0].location, <cydriver.CUmemLocation*><void_ptr>location.getPtr(), sizeof(self._ptr[0].location))
     @property
     def win32SecurityAttributes(self):
         return <void_ptr>self._ptr[0].win32SecurityAttributes
     @win32SecurityAttributes.setter
     def win32SecurityAttributes(self, win32SecurityAttributes):
-        _cwin32SecurityAttributes = utils.HelperInputVoidPtr(win32SecurityAttributes)
-        self._ptr[0].win32SecurityAttributes = <void*><void_ptr>_cwin32SecurityAttributes.cptr
+        _cywin32SecurityAttributes = utils.HelperInputVoidPtr(win32SecurityAttributes)
+        self._ptr[0].win32SecurityAttributes = <void*><void_ptr>_cywin32SecurityAttributes.cptr
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(<char*>self._ptr[0].reserved, 64)
@@ -11603,7 +12387,7 @@ cdef class CUmemPoolProps_st:
         for i, b in enumerate(reserved):
             self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'CUmemPoolPtrExportData_st' in found_types}}
+{{if 'struct CUmemPoolPtrExportData_st' in found_types}}
 
 cdef class CUmemPoolPtrExportData_st:
     """
@@ -11624,7 +12408,7 @@ cdef class CUmemPoolPtrExportData_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemPoolPtrExportData_st *>_ptr
+            self._ptr = <cydriver.CUmemPoolPtrExportData_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -11634,11 +12418,13 @@ cdef class CUmemPoolPtrExportData_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(<char*>self._ptr[0].reserved, 64)
@@ -11649,7 +12435,7 @@ cdef class CUmemPoolPtrExportData_st:
         for i, b in enumerate(reserved):
             self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
+{{if 'struct CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
 
 cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
     """
@@ -11682,7 +12468,7 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUDA_MEM_ALLOC_NODE_PARAMS_st *>_ptr
+            self._ptr = <cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._poolProps = CUmemPoolProps(_ptr=<void_ptr>&self._ptr[0].poolProps)
         self._dptr = CUdeviceptr(_ptr=<void_ptr>&self._ptr[0].dptr)
@@ -11694,29 +12480,38 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['poolProps :\n' + '\n'.join(['    ' + line for line in str(self.poolProps).splitlines()])]
-            str_list += ['accessDescs : ' + str(self.accessDescs)]
-            str_list += ['accessDescCount : ' + str(self.accessDescCount)]
-            str_list += ['bytesize : ' + str(self.bytesize)]
-            str_list += ['dptr : ' + str(self.dptr)]
+            try:
+                str_list += ['poolProps :\n' + '\n'.join(['    ' + line for line in str(self.poolProps).splitlines()])]
+            except ValueError:
+                str_list += ['poolProps : <ValueError>']
+            try:
+                str_list += ['accessDescs : ' + str(self.accessDescs)]
+            except ValueError:
+                str_list += ['accessDescs : <ValueError>']
+            try:
+                str_list += ['accessDescCount : ' + str(self.accessDescCount)]
+            except ValueError:
+                str_list += ['accessDescCount : <ValueError>']
+            try:
+                str_list += ['bytesize : ' + str(self.bytesize)]
+            except ValueError:
+                str_list += ['bytesize : <ValueError>']
+            try:
+                str_list += ['dptr : ' + str(self.dptr)]
+            except ValueError:
+                str_list += ['dptr : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def poolProps(self):
         return self._poolProps
     @poolProps.setter
     def poolProps(self, poolProps not None : CUmemPoolProps):
-        pass
-        for _attr in dir(poolProps):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._poolProps, _attr, getattr(poolProps, _attr))
+        string.memcpy(&self._ptr[0].poolProps, <cydriver.CUmemPoolProps*><void_ptr>poolProps.getPtr(), sizeof(self._ptr[0].poolProps))
     @property
     def accessDescs(self):
-        arrs = [<void_ptr>self._ptr[0].accessDescs + x*sizeof(ccuda.CUmemAccessDesc) for x in range(self._accessDescs_length)]
+        arrs = [<void_ptr>self._ptr[0].accessDescs + x*sizeof(cydriver.CUmemAccessDesc) for x in range(self._accessDescs_length)]
         return [CUmemAccessDesc(_ptr=arr) for arr in arrs]
     @accessDescs.setter
     def accessDescs(self, val):
@@ -11727,53 +12522,52 @@ cdef class CUDA_MEM_ALLOC_NODE_PARAMS_st:
         else:
             if self._accessDescs_length != <size_t>len(val):
                 free(self._accessDescs)
-                self._accessDescs = <ccuda.CUmemAccessDesc*> calloc(len(val), sizeof(ccuda.CUmemAccessDesc))
+                self._accessDescs = <cydriver.CUmemAccessDesc*> calloc(len(val), sizeof(cydriver.CUmemAccessDesc))
                 if self._accessDescs is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccuda.CUmemAccessDesc)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc)))
                 self._accessDescs_length = <size_t>len(val)
                 self._ptr[0].accessDescs = self._accessDescs
             for idx in range(len(val)):
-                memcpy(&self._accessDescs[idx], (<CUmemAccessDesc>val[idx])._ptr, sizeof(ccuda.CUmemAccessDesc))
+                string.memcpy(&self._accessDescs[idx], (<CUmemAccessDesc>val[idx])._ptr, sizeof(cydriver.CUmemAccessDesc))
+
     @property
     def accessDescCount(self):
         return self._ptr[0].accessDescCount
     @accessDescCount.setter
     def accessDescCount(self, size_t accessDescCount):
-        pass
         self._ptr[0].accessDescCount = accessDescCount
     @property
     def bytesize(self):
         return self._ptr[0].bytesize
     @bytesize.setter
     def bytesize(self, size_t bytesize):
-        pass
         self._ptr[0].bytesize = bytesize
     @property
     def dptr(self):
         return self._dptr
     @dptr.setter
     def dptr(self, dptr):
-        cdef ccuda.CUdeviceptr cdptr
+        cdef cydriver.CUdeviceptr cydptr
         if dptr is None:
-            cdptr = <ccuda.CUdeviceptr><void_ptr>0
+            cydptr = <cydriver.CUdeviceptr><void_ptr>0
         elif isinstance(dptr, (CUdeviceptr)):
             pdptr = int(dptr)
-            cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+            cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
         else:
             pdptr = int(CUdeviceptr(dptr))
-            cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-        self._dptr._ptr[0] = cdptr
+            cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+        self._dptr._ptr[0] = cydptr
+
 {{endif}}
-{{if True or 'CUeglFrame_st' in found_types}}
+{{if True}}
 
-cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
+cdef class anon_union11:
     """
-
     Attributes
     ----------
     pArray : List[CUarray]
 
-    pPitch : List[void]
+    pPitch : List[Any]
 
 
     Methods
@@ -11783,20 +12577,28 @@ cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccuda.CUeglFrame_st *>_ptr
+        self._ptr = <cydriver.CUeglFrame_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].frame
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['pArray : ' + str(self.pArray)]
-            str_list += ['pPitch : ' + str(self.pPitch)]
+            try:
+                str_list += ['pArray : ' + str(self.pArray)]
+            except ValueError:
+                str_list += ['pArray : <ValueError>']
+            try:
+                str_list += ['pPitch : ' + hex(self.pPitch)]
+            except ValueError:
+                str_list += ['pPitch : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def pArray(self):
         return [CUarray(init_value=<void_ptr>_pArray) for _pArray in self._ptr[0].frame.pArray]
@@ -11806,7 +12608,8 @@ cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
             raise IndexError('not enough values found during array assignment, expected 3, got', len(pArray))
         pArray = [int(_pArray) for _pArray in pArray]
         for _idx, _pArray in enumerate(pArray):
-            self._ptr[0].frame.pArray[_idx] = <ccuda.CUarray><void_ptr>_pArray
+            self._ptr[0].frame.pArray[_idx] = <cydriver.CUarray><void_ptr>_pArray
+
     @property
     def pPitch(self):
         return [<void_ptr>_pPitch for _pPitch in self._ptr[0].frame.pPitch]
@@ -11818,7 +12621,7 @@ cdef class _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u:
         for _idx, _pPitch in enumerate(pPitch):
             self._ptr[0].frame.pPitch[_idx] = <void*><void_ptr>_pPitch
 {{endif}}
-{{if True or 'CUeglFrame_st' in found_types}}
+{{if True}}
 
 cdef class CUeglFrame_st:
     """
@@ -11828,7 +12631,7 @@ cdef class CUeglFrame_st:
 
     Attributes
     ----------
-    frame : _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u
+    frame : anon_union11
 
     width : unsigned int
         Width of first plane
@@ -11857,105 +12660,122 @@ cdef class CUeglFrame_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cydriver.CUeglFrame_st *>calloc(1, sizeof(cydriver.CUeglFrame_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccuda.CUeglFrame_st *>_ptr
+            self._ptr = <cydriver.CUeglFrame_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._frame = _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u(_ptr=<void_ptr>self._ptr)
+        self._frame = anon_union11(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['frame :\n' + '\n'.join(['    ' + line for line in str(self.frame).splitlines()])]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
-            str_list += ['pitch : ' + str(self.pitch)]
-            str_list += ['planeCount : ' + str(self.planeCount)]
-            str_list += ['numChannels : ' + str(self.numChannels)]
-            str_list += ['frameType : ' + str(self.frameType)]
-            str_list += ['eglColorFormat : ' + str(self.eglColorFormat)]
-            str_list += ['cuFormat : ' + str(self.cuFormat)]
+            try:
+                str_list += ['frame :\n' + '\n'.join(['    ' + line for line in str(self.frame).splitlines()])]
+            except ValueError:
+                str_list += ['frame : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
+            try:
+                str_list += ['pitch : ' + str(self.pitch)]
+            except ValueError:
+                str_list += ['pitch : <ValueError>']
+            try:
+                str_list += ['planeCount : ' + str(self.planeCount)]
+            except ValueError:
+                str_list += ['planeCount : <ValueError>']
+            try:
+                str_list += ['numChannels : ' + str(self.numChannels)]
+            except ValueError:
+                str_list += ['numChannels : <ValueError>']
+            try:
+                str_list += ['frameType : ' + str(self.frameType)]
+            except ValueError:
+                str_list += ['frameType : <ValueError>']
+            try:
+                str_list += ['eglColorFormat : ' + str(self.eglColorFormat)]
+            except ValueError:
+                str_list += ['eglColorFormat : <ValueError>']
+            try:
+                str_list += ['cuFormat : ' + str(self.cuFormat)]
+            except ValueError:
+                str_list += ['cuFormat : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def frame(self):
         return self._frame
     @frame.setter
-    def frame(self, frame not None : _CUeglFrame_v1_CUeglFrame_v1_CUeglFrame_st_frame_u):
-        pass
-        for _attr in dir(frame):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._frame, _attr, getattr(frame, _attr))
+    def frame(self, frame not None : anon_union11):
+        string.memcpy(&self._ptr[0].frame, <cydriver.anon_union11*><void_ptr>frame.getPtr(), sizeof(self._ptr[0].frame))
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, unsigned int width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, unsigned int height):
-        pass
         self._ptr[0].height = height
     @property
     def depth(self):
         return self._ptr[0].depth
     @depth.setter
     def depth(self, unsigned int depth):
-        pass
         self._ptr[0].depth = depth
     @property
     def pitch(self):
         return self._ptr[0].pitch
     @pitch.setter
     def pitch(self, unsigned int pitch):
-        pass
         self._ptr[0].pitch = pitch
     @property
     def planeCount(self):
         return self._ptr[0].planeCount
     @planeCount.setter
     def planeCount(self, unsigned int planeCount):
-        pass
         self._ptr[0].planeCount = planeCount
     @property
     def numChannels(self):
         return self._ptr[0].numChannels
     @numChannels.setter
     def numChannels(self, unsigned int numChannels):
-        pass
         self._ptr[0].numChannels = numChannels
     @property
     def frameType(self):
         return CUeglFrameType(self._ptr[0].frameType)
     @frameType.setter
     def frameType(self, frameType not None : CUeglFrameType):
-        pass
         self._ptr[0].frameType = frameType.value
     @property
     def eglColorFormat(self):
         return CUeglColorFormat(self._ptr[0].eglColorFormat)
     @eglColorFormat.setter
     def eglColorFormat(self, eglColorFormat not None : CUeglColorFormat):
-        pass
         self._ptr[0].eglColorFormat = eglColorFormat.value
     @property
     def cuFormat(self):
         return CUarray_format(self._ptr[0].cuFormat)
     @cuFormat.setter
     def cuFormat(self, cuFormat not None : CUarray_format):
-        pass
         self._ptr[0].cuFormat = cuFormat.value
 {{endif}}
 {{if 'cuuint32_t' in found_types}}
@@ -11973,7 +12793,7 @@ cdef class cuuint32_t:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.cuuint32_t *>_ptr
+            self._ptr = <cydriver.cuuint32_t *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12001,7 +12821,7 @@ cdef class cuuint64_t:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.cuuint64_t *>_ptr
+            self._ptr = <cydriver.cuuint64_t *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12031,7 +12851,7 @@ cdef class CUdeviceptr_v2:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUdeviceptr_v2 *>_ptr
+            self._ptr = <cydriver.CUdeviceptr_v2 *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12044,36 +12864,6 @@ cdef class CUdeviceptr_v2:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUdeviceptr' in found_types}}
-
-cdef class CUdeviceptr:
-    """
-
-    CUDA device pointer
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
-        if _ptr == 0:
-            self._ptr = &self.__val
-        else:
-            self._ptr = <ccuda.CUdeviceptr *>_ptr
-        if init_value:
-            self._ptr[0] = init_value
-    def __dealloc__(self):
-        pass
-    def __repr__(self):
-        return '<CUdeviceptr ' + str(self.__int__()) + '>'
-    def __int__(self):
-        return <unsigned long long>self._ptr[0]
-    def getPtr(self):
-        return <void_ptr>self._ptr
-{{endif}}
-
 {{if 'CUdevice_v1' in found_types}}
 
 cdef class CUdevice_v1:
@@ -12091,7 +12881,7 @@ cdef class CUdevice_v1:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUdevice_v1 *>_ptr
+            self._ptr = <cydriver.CUdevice_v1 *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12104,36 +12894,6 @@ cdef class CUdevice_v1:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUdevice' in found_types}}
-
-cdef class CUdevice:
-    """
-
-    CUDA device
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    def __cinit__(self, int init_value = 0, void_ptr _ptr = 0):
-        if _ptr == 0:
-            self._ptr = &self.__val
-        else:
-            self._ptr = <ccuda.CUdevice *>_ptr
-        if init_value:
-            self._ptr[0] = init_value
-    def __dealloc__(self):
-        pass
-    def __repr__(self):
-        return '<CUdevice ' + str(self.__int__()) + '>'
-    def __int__(self):
-        return <int>self._ptr[0]
-    def getPtr(self):
-        return <void_ptr>self._ptr
-{{endif}}
-
 {{if 'CUtexObject_v1' in found_types}}
 
 cdef class CUtexObject_v1:
@@ -12151,7 +12911,7 @@ cdef class CUtexObject_v1:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUtexObject_v1 *>_ptr
+            self._ptr = <cydriver.CUtexObject_v1 *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12164,36 +12924,6 @@ cdef class CUtexObject_v1:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUtexObject' in found_types}}
-
-cdef class CUtexObject:
-    """
-
-    An opaque value that represents a CUDA texture object
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
-        if _ptr == 0:
-            self._ptr = &self.__val
-        else:
-            self._ptr = <ccuda.CUtexObject *>_ptr
-        if init_value:
-            self._ptr[0] = init_value
-    def __dealloc__(self):
-        pass
-    def __repr__(self):
-        return '<CUtexObject ' + str(self.__int__()) + '>'
-    def __int__(self):
-        return <unsigned long long>self._ptr[0]
-    def getPtr(self):
-        return <void_ptr>self._ptr
-{{endif}}
-
 {{if 'CUsurfObject_v1' in found_types}}
 
 cdef class CUsurfObject_v1:
@@ -12211,7 +12941,7 @@ cdef class CUsurfObject_v1:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUsurfObject_v1 *>_ptr
+            self._ptr = <cydriver.CUsurfObject_v1 *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12224,36 +12954,6 @@ cdef class CUsurfObject_v1:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUsurfObject' in found_types}}
-
-cdef class CUsurfObject:
-    """
-
-    An opaque value that represents a CUDA surface object
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
-        if _ptr == 0:
-            self._ptr = &self.__val
-        else:
-            self._ptr = <ccuda.CUsurfObject *>_ptr
-        if init_value:
-            self._ptr[0] = init_value
-    def __dealloc__(self):
-        pass
-    def __repr__(self):
-        return '<CUsurfObject ' + str(self.__int__()) + '>'
-    def __int__(self):
-        return <unsigned long long>self._ptr[0]
-    def getPtr(self):
-        return <void_ptr>self._ptr
-{{endif}}
-
 {{if 'CUmemGenericAllocationHandle_v1' in found_types}}
 
 cdef class CUmemGenericAllocationHandle_v1:
@@ -12269,7 +12969,7 @@ cdef class CUmemGenericAllocationHandle_v1:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.CUmemGenericAllocationHandle_v1 *>_ptr
+            self._ptr = <cydriver.CUmemGenericAllocationHandle_v1 *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12282,35 +12982,7 @@ cdef class CUmemGenericAllocationHandle_v1:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'CUmemGenericAllocationHandle' in found_types}}
-
-cdef class CUmemGenericAllocationHandle:
-    """
-
-    Methods
-    -------
-    getPtr()
-        Get memory address of class instance
-
-    """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
-        if _ptr == 0:
-            self._ptr = &self.__val
-        else:
-            self._ptr = <ccuda.CUmemGenericAllocationHandle *>_ptr
-        if init_value:
-            self._ptr[0] = init_value
-    def __dealloc__(self):
-        pass
-    def __repr__(self):
-        return '<CUmemGenericAllocationHandle ' + str(self.__int__()) + '>'
-    def __int__(self):
-        return <unsigned long long>self._ptr[0]
-    def getPtr(self):
-        return <void_ptr>self._ptr
-{{endif}}
-
-{{if True or 'GLenum' in found_types}}
+{{if True}}
 
 cdef class GLenum:
     """
@@ -12325,7 +12997,7 @@ cdef class GLenum:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.GLenum *>_ptr
+            self._ptr = <cydriver.GLenum *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12338,7 +13010,7 @@ cdef class GLenum:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'GLuint' in found_types}}
+{{if True}}
 
 cdef class GLuint:
     """
@@ -12353,7 +13025,7 @@ cdef class GLuint:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.GLuint *>_ptr
+            self._ptr = <cydriver.GLuint *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12366,7 +13038,7 @@ cdef class GLuint:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLint' in found_types}}
+{{if True}}
 
 cdef class EGLint:
     """
@@ -12381,7 +13053,7 @@ cdef class EGLint:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.EGLint *>_ptr
+            self._ptr = <cydriver.EGLint *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12394,7 +13066,7 @@ cdef class EGLint:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpDevice' in found_types}}
+{{if True}}
 
 cdef class VdpDevice:
     """
@@ -12409,7 +13081,7 @@ cdef class VdpDevice:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.VdpDevice *>_ptr
+            self._ptr = <cydriver.VdpDevice *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12422,7 +13094,7 @@ cdef class VdpDevice:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpGetProcAddress' in found_types}}
+{{if True}}
 
 cdef class VdpGetProcAddress:
     """
@@ -12437,7 +13109,7 @@ cdef class VdpGetProcAddress:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.VdpGetProcAddress *>_ptr
+            self._ptr = <cydriver.VdpGetProcAddress *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12450,7 +13122,7 @@ cdef class VdpGetProcAddress:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpVideoSurface' in found_types}}
+{{if True}}
 
 cdef class VdpVideoSurface:
     """
@@ -12465,7 +13137,7 @@ cdef class VdpVideoSurface:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.VdpVideoSurface *>_ptr
+            self._ptr = <cydriver.VdpVideoSurface *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12478,7 +13150,7 @@ cdef class VdpVideoSurface:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpOutputSurface' in found_types}}
+{{if True}}
 
 cdef class VdpOutputSurface:
     """
@@ -12493,7 +13165,7 @@ cdef class VdpOutputSurface:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccuda.VdpOutputSurface *>_ptr
+            self._ptr = <cydriver.VdpOutputSurface *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
@@ -12506,7 +13178,6 @@ cdef class VdpOutputSurface:
         return <void_ptr>self._ptr
 {{endif}}
 
-
 {{if 'cuGetErrorString' in found_functions}}
 
 @cython.embedsignature(True)
@@ -12534,9 +13205,9 @@ def cuGetErrorString(error not None : CUresult):
     --------
     :py:obj:`~.CUresult`, :py:obj:`~.cudaGetErrorString`
     """
-    cdef ccuda.CUresult cerror = error.value
+    cdef cydriver.CUresult cyerror = error.value
     cdef const char* pStr = NULL
-    err = ccuda.cuGetErrorString(cerror, &pStr)
+    err = cydriver.cuGetErrorString(cyerror, &pStr)
     return (CUresult(err), <bytes>pStr)
 {{endif}}
 
@@ -12567,9 +13238,9 @@ def cuGetErrorName(error not None : CUresult):
     --------
     :py:obj:`~.CUresult`, :py:obj:`~.cudaGetErrorName`
     """
-    cdef ccuda.CUresult cerror = error.value
+    cdef cydriver.CUresult cyerror = error.value
     cdef const char* pStr = NULL
-    err = ccuda.cuGetErrorName(cerror, &pStr)
+    err = cydriver.cuGetErrorName(cyerror, &pStr)
     return (CUresult(err), <bytes>pStr)
 {{endif}}
 
@@ -12594,7 +13265,7 @@ def cuInit(unsigned int Flags):
     CUresult
         :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_INVALID_DEVICE`, :py:obj:`~.CUDA_ERROR_SYSTEM_DRIVER_MISMATCH`, :py:obj:`~.CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE`
     """
-    err = ccuda.cuInit(Flags)
+    err = cydriver.cuInit(Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -12623,7 +13294,7 @@ def cuDriverGetVersion():
     :py:obj:`~.cudaDriverGetVersion`, :py:obj:`~.cudaRuntimeGetVersion`
     """
     cdef int driverVersion = 0
-    err = ccuda.cuDriverGetVersion(&driverVersion)
+    err = cydriver.cuDriverGetVersion(&driverVersion)
     return (CUresult(err), driverVersion)
 {{endif}}
 
@@ -12653,7 +13324,7 @@ def cuDeviceGet(int ordinal):
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGetLuid`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`
     """
     cdef CUdevice device = CUdevice()
-    err = ccuda.cuDeviceGet(device._ptr, ordinal)
+    err = cydriver.cuDeviceGet(<cydriver.CUdevice*>device._ptr, ordinal)
     return (CUresult(err), device)
 {{endif}}
 
@@ -12679,7 +13350,7 @@ def cuDeviceGetCount():
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGetLuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaGetDeviceCount`
     """
     cdef int count = 0
-    err = ccuda.cuDeviceGetCount(&count)
+    err = cydriver.cuDeviceGetCount(&count)
     return (CUresult(err), count)
 {{endif}}
 
@@ -12711,19 +13382,18 @@ def cuDeviceGetName(int length, dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGetLuid`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaGetDeviceProperties`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     pyname = b" " * length
     cdef char* name = pyname
-    err = ccuda.cuDeviceGetName(name, length, cdev)
+    err = cydriver.cuDeviceGetName(name, length, cydev)
     return (CUresult(err), pyname)
 {{endif}}
 
@@ -12756,18 +13426,17 @@ def cuDeviceGetUuid(dev):
     --------
     :py:obj:`~.cuDeviceGetUuid_v2` :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetLuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaGetDeviceProperties`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUuuid uuid = CUuuid()
-    err = ccuda.cuDeviceGetUuid(uuid._ptr, cdev)
+    err = cydriver.cuDeviceGetUuid(<cydriver.CUuuid*>uuid._ptr, cydev)
     return (CUresult(err), uuid)
 {{endif}}
 
@@ -12797,18 +13466,17 @@ def cuDeviceGetUuid_v2(dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetLuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cudaGetDeviceProperties`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUuuid uuid = CUuuid()
-    err = ccuda.cuDeviceGetUuid_v2(uuid._ptr, cdev)
+    err = cydriver.cuDeviceGetUuid_v2(<cydriver.CUuuid*>uuid._ptr, cydev)
     return (CUresult(err), uuid)
 {{endif}}
 
@@ -12839,19 +13507,18 @@ def cuDeviceGetLuid(dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaGetDeviceProperties`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef char luid[8]
     cdef unsigned int deviceNodeMask = 0
-    err = ccuda.cuDeviceGetLuid(luid, &deviceNodeMask, cdev)
+    err = cydriver.cuDeviceGetLuid(luid, &deviceNodeMask, cydev)
     return (CUresult(err), <bytes>luid, deviceNodeMask)
 {{endif}}
 
@@ -12880,18 +13547,17 @@ def cuDeviceTotalMem(dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaMemGetInfo`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef size_t numbytes = 0
-    err = ccuda.cuDeviceTotalMem(&numbytes, cdev)
+    err = cydriver.cuDeviceTotalMem(&numbytes, cydev)
     return (CUresult(err), numbytes)
 {{endif}}
 
@@ -12926,19 +13592,18 @@ def cuDeviceGetTexture1DLinearMaxWidth(pformat not None : CUarray_format, unsign
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cudaMemGetInfo`, :py:obj:`~.cuDeviceTotalMem`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef size_t maxWidthInElements = 0
-    cdef ccuda.CUarray_format cpformat = pformat.value
-    err = ccuda.cuDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cpformat, numChannels, cdev)
+    cdef cydriver.CUarray_format cypformat = pformat.value
+    err = cydriver.cuDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cypformat, numChannels, cydev)
     return (CUresult(err), maxWidthInElements)
 {{endif}}
 
@@ -13346,19 +14011,18 @@ def cuDeviceGetAttribute(attrib not None : CUdevice_attribute, dev):
     --------
     :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`, :py:obj:`~.cuDeviceGetExecAffinitySupport`, :py:obj:`~.cudaDeviceGetAttribute`, :py:obj:`~.cudaGetDeviceProperties`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef int pi = 0
-    cdef ccuda.CUdevice_attribute cattrib = attrib.value
-    err = ccuda.cuDeviceGetAttribute(&pi, cattrib, cdev)
+    cdef cydriver.CUdevice_attribute cyattrib = attrib.value
+    err = cydriver.cuDeviceGetAttribute(&pi, cyattrib, cydev)
     return (CUresult(err), pi)
 {{endif}}
 
@@ -13421,19 +14085,18 @@ def cuDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, dev, int flags):
     --------
     :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuDestroyExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
-    cnvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
-    cdef void* cnvSciSyncAttrList_ptr = <void*><void_ptr>cnvSciSyncAttrList.cptr
-    err = ccuda.cuDeviceGetNvSciSyncAttributes(cnvSciSyncAttrList_ptr, cdev, flags)
+        cydev = <cydriver.CUdevice>pdev
+    cynvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
+    cdef void* cynvSciSyncAttrList_ptr = <void*><void_ptr>cynvSciSyncAttrList.cptr
+    err = cydriver.cuDeviceGetNvSciSyncAttributes(cynvSciSyncAttrList_ptr, cydev, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -13468,27 +14131,25 @@ def cuDeviceSetMemPool(dev, pool):
     -----
     Use :py:obj:`~.cuMemAllocFromPoolAsync` to specify asynchronous allocations from a device different than the one the stream runs on.
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    cdef ccuda.CUdevice cdev
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
-    err = ccuda.cuDeviceSetMemPool(cdev, cpool)
+        cydev = <cydriver.CUdevice>pdev
+    err = cydriver.cuDeviceSetMemPool(cydev, cypool)
     return (CUresult(err),)
 {{endif}}
 
@@ -13520,18 +14181,17 @@ def cuDeviceGetMemPool(dev):
     --------
     :py:obj:`~.cuDeviceGetDefaultMemPool`, :py:obj:`~.cuMemPoolCreate`, :py:obj:`~.cuDeviceSetMemPool`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUmemoryPool pool = CUmemoryPool()
-    err = ccuda.cuDeviceGetMemPool(pool._ptr, cdev)
+    err = cydriver.cuDeviceGetMemPool(<cydriver.CUmemoryPool*>pool._ptr, cydev)
     return (CUresult(err), pool)
 {{endif}}
 
@@ -13560,18 +14220,17 @@ def cuDeviceGetDefaultMemPool(dev):
     --------
     :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemPoolTrimTo`, :py:obj:`~.cuMemPoolGetAttribute`, :py:obj:`~.cuMemPoolSetAttribute`, :py:obj:`~.cuMemPoolSetAccess`, :py:obj:`~.cuDeviceGetMemPool`, :py:obj:`~.cuMemPoolCreate`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUmemoryPool pool_out = CUmemoryPool()
-    err = ccuda.cuDeviceGetDefaultMemPool(pool_out._ptr, cdev)
+    err = cydriver.cuDeviceGetDefaultMemPool(<cydriver.CUmemoryPool*>pool_out._ptr, cydev)
     return (CUresult(err), pool_out)
 {{endif}}
 
@@ -13609,9 +14268,9 @@ def cuFlushGPUDirectRDMAWrites(target not None : CUflushGPUDirectRDMAWritesTarge
     CUresult
         :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`,
     """
-    cdef ccuda.CUflushGPUDirectRDMAWritesTarget ctarget = target.value
-    cdef ccuda.CUflushGPUDirectRDMAWritesScope cscope = scope.value
-    err = ccuda.cuFlushGPUDirectRDMAWrites(ctarget, cscope)
+    cdef cydriver.CUflushGPUDirectRDMAWritesTarget cytarget = target.value
+    cdef cydriver.CUflushGPUDirectRDMAWritesScope cyscope = scope.value
+    err = cydriver.cuFlushGPUDirectRDMAWrites(cytarget, cyscope)
     return (CUresult(err),)
 {{endif}}
 
@@ -13679,18 +14338,17 @@ def cuDeviceGetProperties(dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUdevprop prop = CUdevprop()
-    err = ccuda.cuDeviceGetProperties(prop._ptr, cdev)
+    err = cydriver.cuDeviceGetProperties(<cydriver.CUdevprop*>prop._ptr, cydev)
     return (CUresult(err), prop)
 {{endif}}
 
@@ -13726,19 +14384,18 @@ def cuDeviceComputeCapability(dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef int major = 0
     cdef int minor = 0
-    err = ccuda.cuDeviceComputeCapability(&major, &minor, cdev)
+    err = cydriver.cuDeviceComputeCapability(&major, &minor, cydev)
     return (CUresult(err), major, minor)
 {{endif}}
 
@@ -13784,18 +14441,17 @@ def cuDevicePrimaryCtxRetain(dev):
     --------
     :py:obj:`~.cuDevicePrimaryCtxRelease`, :py:obj:`~.cuDevicePrimaryCtxSetFlags`, :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuDevicePrimaryCtxRetain(pctx._ptr, cdev)
+    err = cydriver.cuDevicePrimaryCtxRetain(<cydriver.CUcontext*>pctx._ptr, cydev)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -13832,17 +14488,16 @@ def cuDevicePrimaryCtxRelease(dev):
     --------
     :py:obj:`~.cuDevicePrimaryCtxRetain`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
-    err = ccuda.cuDevicePrimaryCtxRelease(cdev)
+        cydev = <cydriver.CUdevice>pdev
+    err = cydriver.cuDevicePrimaryCtxRelease(cydev)
     return (CUresult(err),)
 {{endif}}
 
@@ -13914,17 +14569,16 @@ def cuDevicePrimaryCtxSetFlags(dev, unsigned int flags):
     --------
     :py:obj:`~.cuDevicePrimaryCtxRetain`, :py:obj:`~.cuDevicePrimaryCtxGetState`, :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cudaSetDeviceFlags`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
-    err = ccuda.cuDevicePrimaryCtxSetFlags(cdev, flags)
+        cydev = <cydriver.CUdevice>pdev
+    err = cydriver.cuDevicePrimaryCtxSetFlags(cydev, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -13956,19 +14610,18 @@ def cuDevicePrimaryCtxGetState(dev):
     --------
     :py:obj:`~.cuDevicePrimaryCtxSetFlags`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cudaGetDeviceFlags`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef unsigned int flags = 0
     cdef int active = 0
-    err = ccuda.cuDevicePrimaryCtxGetState(cdev, &flags, &active)
+    err = cydriver.cuDevicePrimaryCtxGetState(cydev, &flags, &active)
     return (CUresult(err), flags, active)
 {{endif}}
 
@@ -14004,17 +14657,16 @@ def cuDevicePrimaryCtxReset(dev):
     --------
     :py:obj:`~.cuDevicePrimaryCtxRetain`, :py:obj:`~.cuDevicePrimaryCtxRelease`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cudaDeviceReset`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
-    err = ccuda.cuDevicePrimaryCtxReset(cdev)
+        cydev = <cydriver.CUdevice>pdev
+    err = cydriver.cuDevicePrimaryCtxReset(cydev)
     return (CUresult(err),)
 {{endif}}
 
@@ -14049,19 +14701,18 @@ def cuDeviceGetExecAffinitySupport(typename not None : CUexecAffinityType, dev):
     --------
     :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetCount`, :py:obj:`~.cuDeviceGetName`, :py:obj:`~.cuDeviceGetUuid`, :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceTotalMem`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef int pi = 0
-    cdef ccuda.CUexecAffinityType ctypename = typename.value
-    err = ccuda.cuDeviceGetExecAffinitySupport(&pi, ctypename, cdev)
+    cdef cydriver.CUexecAffinityType cytypename = typename.value
+    err = cydriver.cuDeviceGetExecAffinitySupport(&pi, cytypename, cydev)
     return (CUresult(err), pi)
 {{endif}}
 
@@ -14157,25 +14808,24 @@ def cuCtxCreate(unsigned int flags, dev):
     -----
     In most cases it is recommended to use :py:obj:`~.cuDevicePrimaryCtxRetain`.
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuCtxCreate(pctx._ptr, flags, cdev)
+    err = cydriver.cuCtxCreate(<cydriver.CUcontext*>pctx._ptr, flags, cydev)
     return (CUresult(err), pctx)
 {{endif}}
 
 {{if 'cuCtxCreate_v3' in found_functions}}
 
 @cython.embedsignature(True)
-def cuCtxCreate_v3(paramsArray : Optional[List[CUexecAffinityParam]], int numParams, unsigned int flags, dev):
+def cuCtxCreate_v3(paramsArray : Optional[Tuple[CUexecAffinityParam] | List[CUexecAffinityParam]], int numParams, unsigned int flags, dev):
     """ Create a CUDA context with execution affinity.
 
     Creates a new CUDA context with execution affinity and associates it
@@ -14280,32 +14930,29 @@ def cuCtxCreate_v3(paramsArray : Optional[List[CUexecAffinityParam]], int numPar
     --------
     :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.CUexecAffinityParam`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     paramsArray = [] if paramsArray is None else paramsArray
-    if not all(isinstance(_x, (CUexecAffinityParam)) for _x in paramsArray):
-        raise TypeError("Argument 'paramsArray' is not instance of type (expected List[ccuda.CUexecAffinityParam]")
-
+    if not all(isinstance(_x, (CUexecAffinityParam,)) for _x in paramsArray):
+        raise TypeError("Argument 'paramsArray' is not instance of type (expected Tuple[cydriver.CUexecAffinityParam,] or List[cydriver.CUexecAffinityParam,]")
     cdef CUcontext pctx = CUcontext()
-    cdef ccuda.CUexecAffinityParam* cparamsArray = NULL
+    cdef cydriver.CUexecAffinityParam* cyparamsArray = NULL
     if len(paramsArray) > 0:
-        cparamsArray = <ccuda.CUexecAffinityParam*> calloc(len(paramsArray), sizeof(ccuda.CUexecAffinityParam))
-        if cparamsArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(ccuda.CUexecAffinityParam)))
+        cyparamsArray = <cydriver.CUexecAffinityParam*> calloc(len(paramsArray), sizeof(cydriver.CUexecAffinityParam))
+        if cyparamsArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(cydriver.CUexecAffinityParam)))
         for idx in range(len(paramsArray)):
-            memcpy(&cparamsArray[idx], (<CUexecAffinityParam>paramsArray[idx])._ptr, sizeof(ccuda.CUexecAffinityParam))
-
-    err = ccuda.cuCtxCreate_v3(pctx._ptr, (<CUexecAffinityParam>paramsArray[0])._ptr if len(paramsArray) == 1 else cparamsArray, numParams, flags, cdev)
-    if cparamsArray is not NULL:
-        free(cparamsArray)
+            string.memcpy(&cyparamsArray[idx], (<CUexecAffinityParam>paramsArray[idx])._ptr, sizeof(cydriver.CUexecAffinityParam))
+    err = cydriver.cuCtxCreate_v3(<cydriver.CUcontext*>pctx._ptr, (<CUexecAffinityParam>paramsArray[0])._ptr if len(paramsArray) == 1 else cyparamsArray, numParams, flags, cydev)
+    if cyparamsArray is not NULL:
+        free(cyparamsArray)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -14352,17 +14999,16 @@ def cuCtxDestroy(ctx):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    err = ccuda.cuCtxDestroy(cctx)
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    err = cydriver.cuCtxDestroy(cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -14394,17 +15040,16 @@ def cuCtxPushCurrent(ctx):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    err = ccuda.cuCtxPushCurrent(cctx)
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    err = cydriver.cuCtxPushCurrent(cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -14434,7 +15079,7 @@ def cuCtxPopCurrent():
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuCtxPopCurrent(pctx._ptr)
+    err = cydriver.cuCtxPopCurrent(<cydriver.CUcontext*>pctx._ptr)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -14468,17 +15113,16 @@ def cuCtxSetCurrent(ctx):
     --------
     :py:obj:`~.cuCtxGetCurrent`, :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cudaSetDevice`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    err = ccuda.cuCtxSetCurrent(cctx)
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    err = cydriver.cuCtxSetCurrent(cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -14504,7 +15148,7 @@ def cuCtxGetCurrent():
     :py:obj:`~.cuCtxSetCurrent`, :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cudaGetDevice`
     """
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuCtxGetCurrent(pctx._ptr)
+    err = cydriver.cuCtxGetCurrent(<cydriver.CUcontext*>pctx._ptr)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -14528,7 +15172,7 @@ def cuCtxGetDevice():
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cudaGetDevice`
     """
     cdef CUdevice device = CUdevice()
-    err = ccuda.cuCtxGetDevice(device._ptr)
+    err = cydriver.cuCtxGetDevice(<cydriver.CUdevice*>device._ptr)
     return (CUresult(err), device)
 {{endif}}
 
@@ -14553,7 +15197,7 @@ def cuCtxGetFlags():
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetCurrent`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxGetSharedMemConfig`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cudaGetDeviceFlags`
     """
     cdef unsigned int flags = 0
-    err = ccuda.cuCtxGetFlags(&flags)
+    err = cydriver.cuCtxGetFlags(&flags)
     return (CUresult(err), flags)
 {{endif}}
 
@@ -14578,7 +15222,7 @@ def cuCtxSynchronize():
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cudaDeviceSynchronize`
     """
-    err = ccuda.cuCtxSynchronize()
+    err = cydriver.cuCtxSynchronize()
     return (CUresult(err),)
 {{endif}}
 
@@ -14683,8 +15327,8 @@ def cuCtxSetLimit(limit not None : CUlimit, size_t value):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cudaDeviceSetLimit`
     """
-    cdef ccuda.CUlimit climit = limit.value
-    err = ccuda.cuCtxSetLimit(climit, value)
+    cdef cydriver.CUlimit cylimit = limit.value
+    err = cydriver.cuCtxSetLimit(cylimit, value)
     return (CUresult(err),)
 {{endif}}
 
@@ -14739,8 +15383,8 @@ def cuCtxGetLimit(limit not None : CUlimit):
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cudaDeviceGetLimit`
     """
     cdef size_t pvalue = 0
-    cdef ccuda.CUlimit climit = limit.value
-    err = ccuda.cuCtxGetLimit(&pvalue, climit)
+    cdef cydriver.CUlimit cylimit = limit.value
+    err = cydriver.cuCtxGetLimit(&pvalue, cylimit)
     return (CUresult(err), pvalue)
 {{endif}}
 
@@ -14784,8 +15428,8 @@ def cuCtxGetCacheConfig():
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`
     """
-    cdef ccuda.CUfunc_cache pconfig
-    err = ccuda.cuCtxGetCacheConfig(&pconfig)
+    cdef cydriver.CUfunc_cache pconfig
+    err = cydriver.cuCtxGetCacheConfig(&pconfig)
     return (CUresult(err), CUfunc_cache(pconfig))
 {{endif}}
 
@@ -14840,8 +15484,8 @@ def cuCtxSetCacheConfig(config not None : CUfunc_cache):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cudaDeviceSetCacheConfig`
     """
-    cdef ccuda.CUfunc_cache cconfig = config.value
-    err = ccuda.cuCtxSetCacheConfig(cconfig)
+    cdef cydriver.CUfunc_cache cyconfig = config.value
+    err = cydriver.cuCtxSetCacheConfig(cyconfig)
     return (CUresult(err),)
 {{endif}}
 
@@ -14878,8 +15522,8 @@ def cuCtxGetSharedMemConfig():
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cuCtxGetSharedMemConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cudaDeviceGetSharedMemConfig`
     """
-    cdef ccuda.CUsharedconfig pConfig
-    err = ccuda.cuCtxGetSharedMemConfig(&pConfig)
+    cdef cydriver.CUsharedconfig pConfig
+    err = cydriver.cuCtxGetSharedMemConfig(&pConfig)
     return (CUresult(err), CUsharedconfig(pConfig))
 {{endif}}
 
@@ -14930,8 +15574,8 @@ def cuCtxSetSharedMemConfig(config not None : CUsharedconfig):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`, :py:obj:`~.cuCtxGetSharedMemConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cudaDeviceSetSharedMemConfig`
     """
-    cdef ccuda.CUsharedconfig cconfig = config.value
-    err = ccuda.cuCtxSetSharedMemConfig(cconfig)
+    cdef cydriver.CUsharedconfig cyconfig = config.value
+    err = cydriver.cuCtxSetSharedMemConfig(cyconfig)
     return (CUresult(err),)
 {{endif}}
 
@@ -14967,18 +15611,17 @@ def cuCtxGetApiVersion(ctx):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     cdef unsigned int version = 0
-    err = ccuda.cuCtxGetApiVersion(cctx, &version)
+    err = cydriver.cuCtxGetApiVersion(cyctx, &version)
     return (CUresult(err), version)
 {{endif}}
 
@@ -15021,7 +15664,7 @@ def cuCtxGetStreamPriorityRange():
     """
     cdef int leastPriority = 0
     cdef int greatestPriority = 0
-    err = ccuda.cuCtxGetStreamPriorityRange(&leastPriority, &greatestPriority)
+    err = cydriver.cuCtxGetStreamPriorityRange(&leastPriority, &greatestPriority)
     return (CUresult(err), leastPriority, greatestPriority)
 {{endif}}
 
@@ -15043,7 +15686,7 @@ def cuCtxResetPersistingL2Cache():
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    err = ccuda.cuCtxResetPersistingL2Cache()
+    err = cydriver.cuCtxResetPersistingL2Cache()
     return (CUresult(err),)
 {{endif}}
 
@@ -15076,8 +15719,8 @@ def cuCtxGetExecAffinity(typename not None : CUexecAffinityType):
     :py:obj:`~.CUexecAffinityParam`
     """
     cdef CUexecAffinityParam pExecAffinity = CUexecAffinityParam()
-    cdef ccuda.CUexecAffinityType ctypename = typename.value
-    err = ccuda.cuCtxGetExecAffinity(pExecAffinity._ptr, ctypename)
+    cdef cydriver.CUexecAffinityType cytypename = typename.value
+    err = cydriver.cuCtxGetExecAffinity(<cydriver.CUexecAffinityParam*>pExecAffinity._ptr, cytypename)
     return (CUresult(err), pExecAffinity)
 {{endif}}
 
@@ -15115,7 +15758,7 @@ def cuCtxAttach(unsigned int flags):
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxDetach`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuCtxAttach(pctx._ptr, flags)
+    err = cydriver.cuCtxAttach(<cydriver.CUcontext*>pctx._ptr, flags)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -15148,17 +15791,16 @@ def cuCtxDetach(ctx):
     --------
     :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuCtxDestroy`, :py:obj:`~.cuCtxGetApiVersion`, :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxGetDevice`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuCtxGetLimit`, :py:obj:`~.cuCtxPopCurrent`, :py:obj:`~.cuCtxPushCurrent`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxSetLimit`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    err = ccuda.cuCtxDetach(cctx)
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    err = cydriver.cuCtxDetach(cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -15194,7 +15836,7 @@ def cuModuleLoad(char* fname):
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`
     """
     cdef CUmodule module = CUmodule()
-    err = ccuda.cuModuleLoad(module._ptr, fname)
+    err = cydriver.cuModuleLoad(<cydriver.CUmodule*>module._ptr, fname)
     return (CUresult(err), module)
 {{endif}}
 
@@ -15229,16 +15871,16 @@ def cuModuleLoadData(image):
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`
     """
     cdef CUmodule module = CUmodule()
-    cimage = utils.HelperInputVoidPtr(image)
-    cdef void* cimage_ptr = <void*><void_ptr>cimage.cptr
-    err = ccuda.cuModuleLoadData(module._ptr, cimage_ptr)
+    cyimage = utils.HelperInputVoidPtr(image)
+    cdef void* cyimage_ptr = <void*><void_ptr>cyimage.cptr
+    err = cydriver.cuModuleLoadData(<cydriver.CUmodule*>module._ptr, cyimage_ptr)
     return (CUresult(err), module)
 {{endif}}
 
 {{if 'cuModuleLoadDataEx' in found_functions}}
 
 @cython.embedsignature(True)
-def cuModuleLoadDataEx(image, unsigned int numOptions, options : Optional[List[CUjit_option]], optionValues : Optional[List[Any]]):
+def cuModuleLoadDataEx(image, unsigned int numOptions, options : Optional[Tuple[CUjit_option] | List[CUjit_option]], optionValues : Optional[Tuple[Any] | List[Any]]):
     """ Load a module's data with options.
 
     Takes a pointer `image` and loads the corresponding module `module`
@@ -15274,19 +15916,19 @@ def cuModuleLoadDataEx(image, unsigned int numOptions, options : Optional[List[C
     --------
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`
     """
+    optionValues = [] if optionValues is None else optionValues
     options = [] if options is None else options
     if not all(isinstance(_x, (CUjit_option)) for _x in options):
-        raise TypeError("Argument 'options' is not instance of type (expected List[ccuda.CUjit_option]")
-
+        raise TypeError("Argument 'options' is not instance of type (expected Tuple[cydriver.CUjit_option] or List[cydriver.CUjit_option]")
     cdef CUmodule module = CUmodule()
-    cimage = utils.HelperInputVoidPtr(image)
-    cdef void* cimage_ptr = <void*><void_ptr>cimage.cptr
+    cyimage = utils.HelperInputVoidPtr(image)
+    cdef void* cyimage_ptr = <void*><void_ptr>cyimage.cptr
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
     if numOptions > len(optionValues): raise RuntimeError("List is too small: " + str(len(optionValues)) + " < " + str(numOptions))
-    cdef vector[ccuda.CUjit_option] coptions = [pyoptions.value for pyoptions in (options)]
+    cdef vector[cydriver.CUjit_option] cyoptions = [pyoptions.value for pyoptions in (options)]
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    err = ccuda.cuModuleLoadDataEx(module._ptr, cimage_ptr, numOptions, coptions.data(), <void**><void_ptr>voidStarHelper.cptr)
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
+    err = cydriver.cuModuleLoadDataEx(<cydriver.CUmodule*>module._ptr, cyimage_ptr, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
     return (CUresult(err), module)
 {{endif}}
 
@@ -15324,9 +15966,9 @@ def cuModuleLoadFatBinary(fatCubin):
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleUnload`
     """
     cdef CUmodule module = CUmodule()
-    cfatCubin = utils.HelperInputVoidPtr(fatCubin)
-    cdef void* cfatCubin_ptr = <void*><void_ptr>cfatCubin.cptr
-    err = ccuda.cuModuleLoadFatBinary(module._ptr, cfatCubin_ptr)
+    cyfatCubin = utils.HelperInputVoidPtr(fatCubin)
+    cdef void* cyfatCubin_ptr = <void*><void_ptr>cyfatCubin.cptr
+    err = cydriver.cuModuleLoadFatBinary(<cydriver.CUmodule*>module._ptr, cyfatCubin_ptr)
     return (CUresult(err), module)
 {{endif}}
 
@@ -15352,17 +15994,16 @@ def cuModuleUnload(hmod):
     --------
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`
     """
-    cdef ccuda.CUmodule chmod
+    cdef cydriver.CUmodule cyhmod
     if hmod is None:
-        chmod = <ccuda.CUmodule><void_ptr>0
-    elif isinstance(hmod, (CUmodule)):
+        cyhmod = <cydriver.CUmodule><void_ptr>0
+    elif isinstance(hmod, (CUmodule,)):
         phmod = int(hmod)
-        chmod = <ccuda.CUmodule><void_ptr>phmod
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     else:
         phmod = int(CUmodule(hmod))
-        chmod = <ccuda.CUmodule><void_ptr>phmod
-
-    err = ccuda.cuModuleUnload(chmod)
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
+    err = cydriver.cuModuleUnload(cyhmod)
     return (CUresult(err),)
 {{endif}}
 
@@ -15386,8 +16027,8 @@ def cuModuleGetLoadingMode():
     --------
     :py:obj:`~.cuModuleLoad`,
     """
-    cdef ccuda.CUmoduleLoadingMode mode
-    err = ccuda.cuModuleGetLoadingMode(&mode)
+    cdef cydriver.CUmoduleLoadingMode mode
+    err = cydriver.cuModuleGetLoadingMode(&mode)
     return (CUresult(err), CUmoduleLoadingMode(mode))
 {{endif}}
 
@@ -15420,18 +16061,17 @@ def cuModuleGetFunction(hmod, char* name):
     --------
     :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`
     """
-    cdef ccuda.CUmodule chmod
+    cdef cydriver.CUmodule cyhmod
     if hmod is None:
-        chmod = <ccuda.CUmodule><void_ptr>0
-    elif isinstance(hmod, (CUmodule)):
+        cyhmod = <cydriver.CUmodule><void_ptr>0
+    elif isinstance(hmod, (CUmodule,)):
         phmod = int(hmod)
-        chmod = <ccuda.CUmodule><void_ptr>phmod
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     else:
         phmod = int(CUmodule(hmod))
-        chmod = <ccuda.CUmodule><void_ptr>phmod
-
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUfunction hfunc = CUfunction()
-    err = ccuda.cuModuleGetFunction(hfunc._ptr, chmod, name)
+    err = cydriver.cuModuleGetFunction(<cydriver.CUfunction*>hfunc._ptr, cyhmod, name)
     return (CUresult(err), hfunc)
 {{endif}}
 
@@ -15467,19 +16107,18 @@ def cuModuleGetGlobal(hmod, char* name):
     --------
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`, :py:obj:`~.cudaGetSymbolAddress`, :py:obj:`~.cudaGetSymbolSize`
     """
-    cdef ccuda.CUmodule chmod
+    cdef cydriver.CUmodule cyhmod
     if hmod is None:
-        chmod = <ccuda.CUmodule><void_ptr>0
-    elif isinstance(hmod, (CUmodule)):
+        cyhmod = <cydriver.CUmodule><void_ptr>0
+    elif isinstance(hmod, (CUmodule,)):
         phmod = int(hmod)
-        chmod = <ccuda.CUmodule><void_ptr>phmod
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     else:
         phmod = int(CUmodule(hmod))
-        chmod = <ccuda.CUmodule><void_ptr>phmod
-
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t numbytes = 0
-    err = ccuda.cuModuleGetGlobal(dptr._ptr, &numbytes, chmod, name)
+    err = cydriver.cuModuleGetGlobal(<cydriver.CUdeviceptr*>dptr._ptr, &numbytes, cyhmod, name)
     return (CUresult(err), dptr, numbytes)
 {{endif}}
 
@@ -15514,18 +16153,17 @@ def cuModuleGetTexRef(hmod, char* name):
     --------
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetSurfRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`, :py:obj:`~.cudaGetTextureReference`
     """
-    cdef ccuda.CUmodule chmod
+    cdef cydriver.CUmodule cyhmod
     if hmod is None:
-        chmod = <ccuda.CUmodule><void_ptr>0
-    elif isinstance(hmod, (CUmodule)):
+        cyhmod = <cydriver.CUmodule><void_ptr>0
+    elif isinstance(hmod, (CUmodule,)):
         phmod = int(hmod)
-        chmod = <ccuda.CUmodule><void_ptr>phmod
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     else:
         phmod = int(CUmodule(hmod))
-        chmod = <ccuda.CUmodule><void_ptr>phmod
-
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUtexref pTexRef = CUtexref()
-    err = ccuda.cuModuleGetTexRef(pTexRef._ptr, chmod, name)
+    err = cydriver.cuModuleGetTexRef(<cydriver.CUtexref*>pTexRef._ptr, cyhmod, name)
     return (CUresult(err), pTexRef)
 {{endif}}
 
@@ -15558,25 +16196,24 @@ def cuModuleGetSurfRef(hmod, char* name):
     --------
     :py:obj:`~.cuModuleGetFunction`, :py:obj:`~.cuModuleGetGlobal`, :py:obj:`~.cuModuleGetTexRef`, :py:obj:`~.cuModuleLoad`, :py:obj:`~.cuModuleLoadData`, :py:obj:`~.cuModuleLoadDataEx`, :py:obj:`~.cuModuleLoadFatBinary`, :py:obj:`~.cuModuleUnload`, :py:obj:`~.cudaGetSurfaceReference`
     """
-    cdef ccuda.CUmodule chmod
+    cdef cydriver.CUmodule cyhmod
     if hmod is None:
-        chmod = <ccuda.CUmodule><void_ptr>0
-    elif isinstance(hmod, (CUmodule)):
+        cyhmod = <cydriver.CUmodule><void_ptr>0
+    elif isinstance(hmod, (CUmodule,)):
         phmod = int(hmod)
-        chmod = <ccuda.CUmodule><void_ptr>phmod
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     else:
         phmod = int(CUmodule(hmod))
-        chmod = <ccuda.CUmodule><void_ptr>phmod
-
+        cyhmod = <cydriver.CUmodule><void_ptr>phmod
     cdef CUsurfref pSurfRef = CUsurfref()
-    err = ccuda.cuModuleGetSurfRef(pSurfRef._ptr, chmod, name)
+    err = cydriver.cuModuleGetSurfRef(<cydriver.CUsurfref*>pSurfRef._ptr, cyhmod, name)
     return (CUresult(err), pSurfRef)
 {{endif}}
 
 {{if 'cuLinkCreate_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cuLinkCreate(unsigned int numOptions, options : Optional[List[CUjit_option]], optionValues : Optional[List[Any]]):
+def cuLinkCreate(unsigned int numOptions, options : Optional[Tuple[CUjit_option] | List[CUjit_option]], optionValues : Optional[Tuple[Any] | List[Any]]):
     """ Creates a pending JIT linker invocation.
 
     If the call is successful, the caller owns the returned CUlinkState,
@@ -15616,18 +16253,18 @@ def cuLinkCreate(unsigned int numOptions, options : Optional[List[CUjit_option]]
     --------
     :py:obj:`~.cuLinkAddData`, :py:obj:`~.cuLinkAddFile`, :py:obj:`~.cuLinkComplete`, :py:obj:`~.cuLinkDestroy`
     """
+    optionValues = [] if optionValues is None else optionValues
     options = [] if options is None else options
     if not all(isinstance(_x, (CUjit_option)) for _x in options):
-        raise TypeError("Argument 'options' is not instance of type (expected List[ccuda.CUjit_option]")
-
+        raise TypeError("Argument 'options' is not instance of type (expected Tuple[cydriver.CUjit_option] or List[cydriver.CUjit_option]")
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
     if numOptions > len(optionValues): raise RuntimeError("List is too small: " + str(len(optionValues)) + " < " + str(numOptions))
-    cdef vector[ccuda.CUjit_option] coptions = [pyoptions.value for pyoptions in (options)]
+    cdef vector[cydriver.CUjit_option] cyoptions = [pyoptions.value for pyoptions in (options)]
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
     cdef CUlinkState stateOut = CUlinkState()
-    err = ccuda.cuLinkCreate(numOptions, coptions.data(), <void**><void_ptr>voidStarHelper.cptr, stateOut._ptr)
-    stateOut._keepalive.append(voidStarHelper)
+    err = cydriver.cuLinkCreate(numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr, stateOut._ptr)
+    stateOut._keepalive.append(voidStarHelperoptionValues)
     for option in pylist:
         stateOut._keepalive.append(option)
     return (CUresult(err), stateOut)
@@ -15636,7 +16273,7 @@ def cuLinkCreate(unsigned int numOptions, options : Optional[List[CUjit_option]]
 {{if 'cuLinkAddData_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cuLinkAddData(state, typename not None : CUjitInputType, data, size_t size, char* name, unsigned int numOptions, options : Optional[List[CUjit_option]], optionValues : Optional[List[Any]]):
+def cuLinkAddData(state, typename not None : CUjitInputType, data, size_t size, char* name, unsigned int numOptions, options : Optional[Tuple[CUjit_option] | List[CUjit_option]], optionValues : Optional[Tuple[Any] | List[Any]]):
     """ Add an input to a pending linker invocation.
 
     Ownership of `data` is retained by the caller. No reference is retained
@@ -15677,36 +16314,35 @@ def cuLinkAddData(state, typename not None : CUjitInputType, data, size_t size,
     --------
     :py:obj:`~.cuLinkCreate`, :py:obj:`~.cuLinkAddFile`, :py:obj:`~.cuLinkComplete`, :py:obj:`~.cuLinkDestroy`
     """
+    optionValues = [] if optionValues is None else optionValues
     options = [] if options is None else options
     if not all(isinstance(_x, (CUjit_option)) for _x in options):
-        raise TypeError("Argument 'options' is not instance of type (expected List[ccuda.CUjit_option]")
-
-    cdef ccuda.CUlinkState cstate
+        raise TypeError("Argument 'options' is not instance of type (expected Tuple[cydriver.CUjit_option] or List[cydriver.CUjit_option]")
+    cdef cydriver.CUlinkState cystate
     if state is None:
-        cstate = <ccuda.CUlinkState><void_ptr>0
-    elif isinstance(state, (CUlinkState)):
+        cystate = <cydriver.CUlinkState><void_ptr>0
+    elif isinstance(state, (CUlinkState,)):
         pstate = int(state)
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
     else:
         pstate = int(CUlinkState(state))
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
-
-    cdef ccuda.CUjitInputType ctypename = typename.value
-    cdata = utils.HelperInputVoidPtr(data)
-    cdef void* cdata_ptr = <void*><void_ptr>cdata.cptr
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
+    cdef cydriver.CUjitInputType cytypename = typename.value
+    cydata = utils.HelperInputVoidPtr(data)
+    cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
     if numOptions > len(optionValues): raise RuntimeError("List is too small: " + str(len(optionValues)) + " < " + str(numOptions))
-    cdef vector[ccuda.CUjit_option] coptions = [pyoptions.value for pyoptions in (options)]
+    cdef vector[cydriver.CUjit_option] cyoptions = [pyoptions.value for pyoptions in (options)]
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    err = ccuda.cuLinkAddData(cstate, ctypename, cdata_ptr, size, name, numOptions, coptions.data(), <void**><void_ptr>voidStarHelper.cptr)
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
+    err = cydriver.cuLinkAddData(cystate, cytypename, cydata_ptr, size, name, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuLinkAddFile_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cuLinkAddFile(state, typename not None : CUjitInputType, char* path, unsigned int numOptions, options : Optional[List[CUjit_option]], optionValues : Optional[List[Any]]):
+def cuLinkAddFile(state, typename not None : CUjitInputType, char* path, unsigned int numOptions, options : Optional[Tuple[CUjit_option] | List[CUjit_option]], optionValues : Optional[Tuple[Any] | List[Any]]):
     """ Add a file input to a pending linker invocation.
 
     No reference is retained to any inputs after this call returns.
@@ -15745,27 +16381,26 @@ def cuLinkAddFile(state, typename not None : CUjitInputType, char* path, unsigne
     --------
     :py:obj:`~.cuLinkCreate`, :py:obj:`~.cuLinkAddData`, :py:obj:`~.cuLinkComplete`, :py:obj:`~.cuLinkDestroy`
     """
+    optionValues = [] if optionValues is None else optionValues
     options = [] if options is None else options
     if not all(isinstance(_x, (CUjit_option)) for _x in options):
-        raise TypeError("Argument 'options' is not instance of type (expected List[ccuda.CUjit_option]")
-
-    cdef ccuda.CUlinkState cstate
+        raise TypeError("Argument 'options' is not instance of type (expected Tuple[cydriver.CUjit_option] or List[cydriver.CUjit_option]")
+    cdef cydriver.CUlinkState cystate
     if state is None:
-        cstate = <ccuda.CUlinkState><void_ptr>0
-    elif isinstance(state, (CUlinkState)):
+        cystate = <cydriver.CUlinkState><void_ptr>0
+    elif isinstance(state, (CUlinkState,)):
         pstate = int(state)
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
     else:
         pstate = int(CUlinkState(state))
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
-
-    cdef ccuda.CUjitInputType ctypename = typename.value
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
+    cdef cydriver.CUjitInputType cytypename = typename.value
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
     if numOptions > len(optionValues): raise RuntimeError("List is too small: " + str(len(optionValues)) + " < " + str(numOptions))
-    cdef vector[ccuda.CUjit_option] coptions = [pyoptions.value for pyoptions in (options)]
+    cdef vector[cydriver.CUjit_option] cyoptions = [pyoptions.value for pyoptions in (options)]
     pylist = [utils.HelperCUjit_option(pyoptions, pyoptionValues) for pyoptions, pyoptionValues in zip(options, optionValues)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    err = ccuda.cuLinkAddFile(cstate, ctypename, path, numOptions, coptions.data(), <void**><void_ptr>voidStarHelper.cptr)
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperoptionValues = utils.InputVoidPtrPtrHelper(pylist)
+    err = cydriver.cuLinkAddFile(cystate, cytypename, path, numOptions, cyoptions.data(), <void**><void_ptr>voidStarHelperoptionValues.cptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -15799,19 +16434,18 @@ def cuLinkComplete(state):
     --------
     :py:obj:`~.cuLinkCreate`, :py:obj:`~.cuLinkAddData`, :py:obj:`~.cuLinkAddFile`, :py:obj:`~.cuLinkDestroy`, :py:obj:`~.cuModuleLoadData`
     """
-    cdef ccuda.CUlinkState cstate
+    cdef cydriver.CUlinkState cystate
     if state is None:
-        cstate = <ccuda.CUlinkState><void_ptr>0
-    elif isinstance(state, (CUlinkState)):
+        cystate = <cydriver.CUlinkState><void_ptr>0
+    elif isinstance(state, (CUlinkState,)):
         pstate = int(state)
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
     else:
         pstate = int(CUlinkState(state))
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
-
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
     cdef void_ptr cubinOut = 0
     cdef size_t sizeOut = 0
-    err = ccuda.cuLinkComplete(cstate, <void**>&cubinOut, &sizeOut)
+    err = cydriver.cuLinkComplete(cystate, <void**>&cubinOut, &sizeOut)
     return (CUresult(err), cubinOut, sizeOut)
 {{endif}}
 
@@ -15835,17 +16469,16 @@ def cuLinkDestroy(state):
     --------
     :py:obj:`~.cuLinkCreate`
     """
-    cdef ccuda.CUlinkState cstate
+    cdef cydriver.CUlinkState cystate
     if state is None:
-        cstate = <ccuda.CUlinkState><void_ptr>0
-    elif isinstance(state, (CUlinkState)):
+        cystate = <cydriver.CUlinkState><void_ptr>0
+    elif isinstance(state, (CUlinkState,)):
         pstate = int(state)
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
     else:
         pstate = int(CUlinkState(state))
-        cstate = <ccuda.CUlinkState><void_ptr>pstate
-
-    err = ccuda.cuLinkDestroy(cstate)
+        cystate = <cydriver.CUlinkState><void_ptr>pstate
+    err = cydriver.cuLinkDestroy(cystate)
     return (CUresult(err),)
 {{endif}}
 
@@ -15887,7 +16520,7 @@ def cuMemGetInfo():
     """
     cdef size_t free = 0
     cdef size_t total = 0
-    err = ccuda.cuMemGetInfo(&free, &total)
+    err = cydriver.cuMemGetInfo(&free, &total)
     return (CUresult(err), free, total)
 {{endif}}
 
@@ -15920,7 +16553,7 @@ def cuMemAlloc(size_t bytesize):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMalloc`
     """
     cdef CUdeviceptr dptr = CUdeviceptr()
-    err = ccuda.cuMemAlloc(dptr._ptr, bytesize)
+    err = cydriver.cuMemAlloc(<cydriver.CUdeviceptr*>dptr._ptr, bytesize)
     return (CUresult(err), dptr)
 {{endif}}
 
@@ -15986,7 +16619,7 @@ def cuMemAllocPitch(size_t WidthInBytes, size_t Height, unsigned int ElementSize
     """
     cdef CUdeviceptr dptr = CUdeviceptr()
     cdef size_t pPitch = 0
-    err = ccuda.cuMemAllocPitch(dptr._ptr, &pPitch, WidthInBytes, Height, ElementSizeBytes)
+    err = cydriver.cuMemAllocPitch(<cydriver.CUdeviceptr*>dptr._ptr, &pPitch, WidthInBytes, Height, ElementSizeBytes)
     return (CUresult(err), dptr, pPitch)
 {{endif}}
 
@@ -16024,17 +16657,16 @@ def cuMemFree(dptr):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemAllocManaged`, :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemAllocFromPoolAsync`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaFree`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    err = ccuda.cuMemFree(cdptr)
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    err = cydriver.cuMemFree(cydptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -16067,19 +16699,18 @@ def cuMemGetAddressRange(dptr):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     cdef CUdeviceptr pbase = CUdeviceptr()
     cdef size_t psize = 0
-    err = ccuda.cuMemGetAddressRange(pbase._ptr, &psize, cdptr)
+    err = cydriver.cuMemGetAddressRange(<cydriver.CUdeviceptr*>pbase._ptr, &psize, cydptr)
     return (CUresult(err), pbase, psize)
 {{endif}}
 
@@ -16126,7 +16757,7 @@ def cuMemAllocHost(size_t bytesize):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMallocHost`
     """
     cdef void_ptr pp = 0
-    err = ccuda.cuMemAllocHost(<void**>&pp, bytesize)
+    err = cydriver.cuMemAllocHost(<void**>&pp, bytesize)
     return (CUresult(err), pp)
 {{endif}}
 
@@ -16153,9 +16784,9 @@ def cuMemFreeHost(p):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaFreeHost`
     """
-    cp = utils.HelperInputVoidPtr(p)
-    cdef void* cp_ptr = <void*><void_ptr>cp.cptr
-    err = ccuda.cuMemFreeHost(cp_ptr)
+    cyp = utils.HelperInputVoidPtr(p)
+    cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
+    err = cydriver.cuMemFreeHost(cyp_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -16239,7 +16870,7 @@ def cuMemHostAlloc(size_t bytesize, unsigned int Flags):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaHostAlloc`
     """
     cdef void_ptr pp = 0
-    err = ccuda.cuMemHostAlloc(<void**>&pp, bytesize, Flags)
+    err = cydriver.cuMemHostAlloc(<void**>&pp, bytesize, Flags)
     return (CUresult(err), pp)
 {{endif}}
 
@@ -16297,9 +16928,9 @@ def cuMemHostGetDevicePointer(p, unsigned int Flags):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaHostGetDevicePointer`
     """
     cdef CUdeviceptr pdptr = CUdeviceptr()
-    cp = utils.HelperInputVoidPtr(p)
-    cdef void* cp_ptr = <void*><void_ptr>cp.cptr
-    err = ccuda.cuMemHostGetDevicePointer(pdptr._ptr, cp_ptr, Flags)
+    cyp = utils.HelperInputVoidPtr(p)
+    cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
+    err = cydriver.cuMemHostGetDevicePointer(<cydriver.CUdeviceptr*>pdptr._ptr, cyp_ptr, Flags)
     return (CUresult(err), pdptr)
 {{endif}}
 
@@ -16333,9 +16964,9 @@ def cuMemHostGetFlags(p):
     :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cudaHostGetFlags`
     """
     cdef unsigned int pFlags = 0
-    cp = utils.HelperInputVoidPtr(p)
-    cdef void* cp_ptr = <void*><void_ptr>cp.cptr
-    err = ccuda.cuMemHostGetFlags(&pFlags, cp_ptr)
+    cyp = utils.HelperInputVoidPtr(p)
+    cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
+    err = cydriver.cuMemHostGetFlags(&pFlags, cyp_ptr)
     return (CUresult(err), pFlags)
 {{endif}}
 
@@ -16470,7 +17101,7 @@ def cuMemAllocManaged(size_t bytesize, unsigned int flags):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuStreamAttachMemAsync`, :py:obj:`~.cudaMallocManaged`
     """
     cdef CUdeviceptr dptr = CUdeviceptr()
-    err = ccuda.cuMemAllocManaged(dptr._ptr, bytesize, flags)
+    err = cydriver.cuMemAllocManaged(<cydriver.CUdeviceptr*>dptr._ptr, bytesize, flags)
     return (CUresult(err), dptr)
 {{endif}}
 
@@ -16502,7 +17133,7 @@ def cuDeviceGetByPCIBusId(char* pciBusId):
     :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetPCIBusId`, :py:obj:`~.cudaDeviceGetByPCIBusId`
     """
     cdef CUdevice dev = CUdevice()
-    err = ccuda.cuDeviceGetByPCIBusId(dev._ptr, pciBusId)
+    err = cydriver.cuDeviceGetByPCIBusId(<cydriver.CUdevice*>dev._ptr, pciBusId)
     return (CUresult(err), dev)
 {{endif}}
 
@@ -16538,19 +17169,18 @@ def cuDeviceGetPCIBusId(int length, dev):
     --------
     :py:obj:`~.cuDeviceGet`, :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetByPCIBusId`, :py:obj:`~.cudaDeviceGetPCIBusId`
     """
-    cdef ccuda.CUdevice cdev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     pypciBusId = b" " * length
     cdef char* pciBusId = pypciBusId
-    err = ccuda.cuDeviceGetPCIBusId(pciBusId, length, cdev)
+    err = cydriver.cuDeviceGetPCIBusId(pciBusId, length, cydev)
     return (CUresult(err), pypciBusId)
 {{endif}}
 
@@ -16596,18 +17226,17 @@ def cuIpcGetEventHandle(event):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuIpcOpenEventHandle`, :py:obj:`~.cuIpcGetMemHandle`, :py:obj:`~.cuIpcOpenMemHandle`, :py:obj:`~.cuIpcCloseMemHandle`, :py:obj:`~.cudaIpcGetEventHandle`
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     cdef CUipcEventHandle pHandle = CUipcEventHandle()
-    err = ccuda.cuIpcGetEventHandle(pHandle._ptr, cevent)
+    err = cydriver.cuIpcGetEventHandle(<cydriver.CUipcEventHandle*>pHandle._ptr, cyevent)
     return (CUresult(err), pHandle)
 {{endif}}
 
@@ -16648,7 +17277,7 @@ def cuIpcOpenEventHandle(handle not None : CUipcEventHandle):
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuIpcGetEventHandle`, :py:obj:`~.cuIpcGetMemHandle`, :py:obj:`~.cuIpcOpenMemHandle`, :py:obj:`~.cuIpcCloseMemHandle`, :py:obj:`~.cudaIpcOpenEventHandle`
     """
     cdef CUevent phEvent = CUevent()
-    err = ccuda.cuIpcOpenEventHandle(phEvent._ptr, handle._ptr[0])
+    err = cydriver.cuIpcOpenEventHandle(<cydriver.CUevent*>phEvent._ptr, handle._ptr[0])
     return (CUresult(err), phEvent)
 {{endif}}
 
@@ -16689,18 +17318,17 @@ def cuIpcGetMemHandle(dptr):
     --------
     :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuIpcGetEventHandle`, :py:obj:`~.cuIpcOpenEventHandle`, :py:obj:`~.cuIpcOpenMemHandle`, :py:obj:`~.cuIpcCloseMemHandle`, :py:obj:`~.cudaIpcGetMemHandle`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     cdef CUipcMemHandle pHandle = CUipcMemHandle()
-    err = ccuda.cuIpcGetMemHandle(pHandle._ptr, cdptr)
+    err = cydriver.cuIpcGetMemHandle(<cydriver.CUipcMemHandle*>pHandle._ptr, cydptr)
     return (CUresult(err), pHandle)
 {{endif}}
 
@@ -16763,7 +17391,7 @@ def cuIpcOpenMemHandle(handle not None : CUipcMemHandle, unsigned int Flags):
     No guarantees are made about the address returned in `*pdptr`. In particular, multiple processes may not receive the same address for the same `handle`.
     """
     cdef CUdeviceptr pdptr = CUdeviceptr()
-    err = ccuda.cuIpcOpenMemHandle(pdptr._ptr, handle._ptr[0], Flags)
+    err = cydriver.cuIpcOpenMemHandle(<cydriver.CUdeviceptr*>pdptr._ptr, handle._ptr[0], Flags)
     return (CUresult(err), pdptr)
 {{endif}}
 
@@ -16800,17 +17428,16 @@ def cuIpcCloseMemHandle(dptr):
     --------
     :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuIpcGetEventHandle`, :py:obj:`~.cuIpcOpenEventHandle`, :py:obj:`~.cuIpcGetMemHandle`, :py:obj:`~.cuIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    err = ccuda.cuIpcCloseMemHandle(cdptr)
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    err = cydriver.cuIpcCloseMemHandle(cydptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -16907,9 +17534,9 @@ def cuMemHostRegister(p, size_t bytesize, unsigned int Flags):
     --------
     :py:obj:`~.cuMemHostUnregister`, :py:obj:`~.cuMemHostGetFlags`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cudaHostRegister`
     """
-    cp = utils.HelperInputVoidPtr(p)
-    cdef void* cp_ptr = <void*><void_ptr>cp.cptr
-    err = ccuda.cuMemHostRegister(cp_ptr, bytesize, Flags)
+    cyp = utils.HelperInputVoidPtr(p)
+    cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
+    err = cydriver.cuMemHostRegister(cyp_ptr, bytesize, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -16939,9 +17566,9 @@ def cuMemHostUnregister(p):
     --------
     :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cudaHostUnregister`
     """
-    cp = utils.HelperInputVoidPtr(p)
-    cdef void* cp_ptr = <void*><void_ptr>cp.cptr
-    err = ccuda.cuMemHostUnregister(cp_ptr)
+    cyp = utils.HelperInputVoidPtr(p)
+    cdef void* cyp_ptr = <void*><void_ptr>cyp.cptr
+    err = cydriver.cuMemHostUnregister(cyp_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -16976,27 +17603,25 @@ def cuMemcpy(dst, src, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`
     """
-    cdef ccuda.CUdeviceptr csrc
+    cdef cydriver.CUdeviceptr cysrc
     if src is None:
-        csrc = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(src, (CUdeviceptr)):
+        cysrc = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(src, (CUdeviceptr,)):
         psrc = int(src)
-        csrc = <ccuda.CUdeviceptr><void_ptr>psrc
+        cysrc = <cydriver.CUdeviceptr><void_ptr>psrc
     else:
         psrc = int(CUdeviceptr(src))
-        csrc = <ccuda.CUdeviceptr><void_ptr>psrc
-
-    cdef ccuda.CUdeviceptr cdst
+        cysrc = <cydriver.CUdeviceptr><void_ptr>psrc
+    cdef cydriver.CUdeviceptr cydst
     if dst is None:
-        cdst = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dst, (CUdeviceptr)):
+        cydst = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dst, (CUdeviceptr,)):
         pdst = int(dst)
-        cdst = <ccuda.CUdeviceptr><void_ptr>pdst
+        cydst = <cydriver.CUdeviceptr><void_ptr>pdst
     else:
         pdst = int(CUdeviceptr(dst))
-        cdst = <ccuda.CUdeviceptr><void_ptr>pdst
-
-    err = ccuda.cuMemcpy(cdst, csrc, ByteCount)
+        cydst = <cydriver.CUdeviceptr><void_ptr>pdst
+    err = cydriver.cuMemcpy(cydst, cysrc, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17034,47 +17659,43 @@ def cuMemcpyPeer(dstDevice, dstContext, srcDevice, srcContext, size_t ByteCount)
     --------
     :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpy3DPeer`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyPeerAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cudaMemcpyPeer`
     """
-    cdef ccuda.CUcontext csrcContext
+    cdef cydriver.CUcontext cysrcContext
     if srcContext is None:
-        csrcContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(srcContext, (CUcontext)):
+        cysrcContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(srcContext, (CUcontext,)):
         psrcContext = int(srcContext)
-        csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
+        cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
     else:
         psrcContext = int(CUcontext(srcContext))
-        csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
-
-    cdef ccuda.CUdeviceptr csrcDevice
+        cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdef ccuda.CUcontext cdstContext
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cdef cydriver.CUcontext cydstContext
     if dstContext is None:
-        cdstContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(dstContext, (CUcontext)):
+        cydstContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(dstContext, (CUcontext,)):
         pdstContext = int(dstContext)
-        cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
+        cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
     else:
         pdstContext = int(CUcontext(dstContext))
-        cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemcpyPeer(cdstDevice, cdstContext, csrcDevice, csrcContext, ByteCount)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemcpyPeer(cydstDevice, cydstContext, cysrcDevice, cysrcContext, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17106,19 +17727,18 @@ def cuMemcpyHtoD(dstDevice, srcHost, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyToSymbol`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    csrcHost = utils.HelperInputVoidPtr(srcHost)
-    cdef void* csrcHost_ptr = <void*><void_ptr>csrcHost.cptr
-    err = ccuda.cuMemcpyHtoD(cdstDevice, csrcHost_ptr, ByteCount)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    cysrcHost = utils.HelperInputVoidPtr(srcHost)
+    cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
+    err = cydriver.cuMemcpyHtoD(cydstDevice, cysrcHost_ptr, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17150,19 +17770,18 @@ def cuMemcpyDtoH(dstHost, srcDevice, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyFromSymbol`
     """
-    cdef ccuda.CUdeviceptr csrcDevice
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdstHost = utils.HelperInputVoidPtr(dstHost)
-    cdef void* cdstHost_ptr = <void*><void_ptr>cdstHost.cptr
-    err = ccuda.cuMemcpyDtoH(cdstHost_ptr, csrcDevice, ByteCount)
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cydstHost = utils.HelperInputVoidPtr(dstHost)
+    cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
+    err = cydriver.cuMemcpyDtoH(cydstHost_ptr, cysrcDevice, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17194,27 +17813,25 @@ def cuMemcpyDtoD(dstDevice, srcDevice, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`
     """
-    cdef ccuda.CUdeviceptr csrcDevice
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemcpyDtoD(cdstDevice, csrcDevice, ByteCount)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemcpyDtoD(cydstDevice, cysrcDevice, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17249,27 +17866,25 @@ def cuMemcpyDtoA(dstArray, size_t dstOffset, srcDevice, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpyToArray`
     """
-    cdef ccuda.CUdeviceptr csrcDevice
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdef ccuda.CUarray cdstArray
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cdef cydriver.CUarray cydstArray
     if dstArray is None:
-        cdstArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(dstArray, (CUarray)):
+        cydstArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(dstArray, (CUarray,)):
         pdstArray = int(dstArray)
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     else:
         pdstArray = int(CUarray(dstArray))
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-
-    err = ccuda.cuMemcpyDtoA(cdstArray, dstOffset, csrcDevice, ByteCount)
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+    err = cydriver.cuMemcpyDtoA(cydstArray, dstOffset, cysrcDevice, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17306,27 +17921,25 @@ def cuMemcpyAtoD(dstDevice, srcArray, size_t srcOffset, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpyFromArray`
     """
-    cdef ccuda.CUarray csrcArray
+    cdef cydriver.CUarray cysrcArray
     if srcArray is None:
-        csrcArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(srcArray, (CUarray)):
+        cysrcArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(srcArray, (CUarray,)):
         psrcArray = int(srcArray)
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
     else:
         psrcArray = int(CUarray(srcArray))
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemcpyAtoD(cdstDevice, csrcArray, srcOffset, ByteCount)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemcpyAtoD(cydstDevice, cysrcArray, srcOffset, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17361,19 +17974,18 @@ def cuMemcpyHtoA(dstArray, size_t dstOffset, srcHost, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpyToArray`
     """
-    cdef ccuda.CUarray cdstArray
+    cdef cydriver.CUarray cydstArray
     if dstArray is None:
-        cdstArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(dstArray, (CUarray)):
+        cydstArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(dstArray, (CUarray,)):
         pdstArray = int(dstArray)
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     else:
         pdstArray = int(CUarray(dstArray))
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-
-    csrcHost = utils.HelperInputVoidPtr(srcHost)
-    cdef void* csrcHost_ptr = <void*><void_ptr>csrcHost.cptr
-    err = ccuda.cuMemcpyHtoA(cdstArray, dstOffset, csrcHost_ptr, ByteCount)
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+    cysrcHost = utils.HelperInputVoidPtr(srcHost)
+    cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
+    err = cydriver.cuMemcpyHtoA(cydstArray, dstOffset, cysrcHost_ptr, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17408,19 +18020,18 @@ def cuMemcpyAtoH(dstHost, srcArray, size_t srcOffset, size_t ByteCount):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpyFromArray`
     """
-    cdef ccuda.CUarray csrcArray
+    cdef cydriver.CUarray cysrcArray
     if srcArray is None:
-        csrcArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(srcArray, (CUarray)):
+        cysrcArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(srcArray, (CUarray,)):
         psrcArray = int(srcArray)
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
     else:
         psrcArray = int(CUarray(srcArray))
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-
-    cdstHost = utils.HelperInputVoidPtr(dstHost)
-    cdef void* cdstHost_ptr = <void*><void_ptr>cdstHost.cptr
-    err = ccuda.cuMemcpyAtoH(cdstHost_ptr, csrcArray, srcOffset, ByteCount)
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+    cydstHost = utils.HelperInputVoidPtr(dstHost)
+    cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
+    err = cydriver.cuMemcpyAtoH(cydstHost_ptr, cysrcArray, srcOffset, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17460,27 +18071,25 @@ def cuMemcpyAtoA(dstArray, size_t dstOffset, srcArray, size_t srcOffset, size_t
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpyArrayToArray`
     """
-    cdef ccuda.CUarray csrcArray
+    cdef cydriver.CUarray cysrcArray
     if srcArray is None:
-        csrcArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(srcArray, (CUarray)):
+        cysrcArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(srcArray, (CUarray,)):
         psrcArray = int(srcArray)
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
     else:
         psrcArray = int(CUarray(srcArray))
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-
-    cdef ccuda.CUarray cdstArray
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+    cdef cydriver.CUarray cydstArray
     if dstArray is None:
-        cdstArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(dstArray, (CUarray)):
+        cydstArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(dstArray, (CUarray,)):
         pdstArray = int(dstArray)
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     else:
         pdstArray = int(CUarray(dstArray))
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-
-    err = ccuda.cuMemcpyAtoA(cdstArray, dstOffset, csrcArray, srcOffset, ByteCount)
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+    err = cydriver.cuMemcpyAtoA(cydstArray, dstOffset, cysrcArray, srcOffset, ByteCount)
     return (CUresult(err),)
 {{endif}}
 
@@ -17605,8 +18214,8 @@ def cuMemcpy2D(pCopy : Optional[CUDA_MEMCPY2D]):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`
     """
-    cdef ccuda.CUDA_MEMCPY2D* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy2D(cpCopy_ptr)
+    cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy2D(cypCopy_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -17731,8 +18340,8 @@ def cuMemcpy2DUnaligned(pCopy : Optional[CUDA_MEMCPY2D]):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`
     """
-    cdef ccuda.CUDA_MEMCPY2D* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy2DUnaligned(cpCopy_ptr)
+    cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy2DUnaligned(cypCopy_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -17860,8 +18469,8 @@ def cuMemcpy3D(pCopy : Optional[CUDA_MEMCPY3D]):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemcpy3D`
     """
-    cdef ccuda.CUDA_MEMCPY3D* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy3D(cpCopy_ptr)
+    cdef cydriver.CUDA_MEMCPY3D* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy3D(cypCopy_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -17889,8 +18498,8 @@ def cuMemcpy3DPeer(pCopy : Optional[CUDA_MEMCPY3D_PEER]):
     --------
     :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyPeerAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cudaMemcpy3DPeer`
     """
-    cdef ccuda.CUDA_MEMCPY3D_PEER* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy3DPeer(cpCopy_ptr)
+    cdef cydriver.CUDA_MEMCPY3D_PEER* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy3DPeer(cypCopy_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -17927,37 +18536,34 @@ def cuMemcpyAsync(dst, src, size_t ByteCount, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr csrc
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cysrc
     if src is None:
-        csrc = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(src, (CUdeviceptr)):
+        cysrc = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(src, (CUdeviceptr,)):
         psrc = int(src)
-        csrc = <ccuda.CUdeviceptr><void_ptr>psrc
+        cysrc = <cydriver.CUdeviceptr><void_ptr>psrc
     else:
         psrc = int(CUdeviceptr(src))
-        csrc = <ccuda.CUdeviceptr><void_ptr>psrc
-
-    cdef ccuda.CUdeviceptr cdst
+        cysrc = <cydriver.CUdeviceptr><void_ptr>psrc
+    cdef cydriver.CUdeviceptr cydst
     if dst is None:
-        cdst = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dst, (CUdeviceptr)):
+        cydst = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dst, (CUdeviceptr,)):
         pdst = int(dst)
-        cdst = <ccuda.CUdeviceptr><void_ptr>pdst
+        cydst = <cydriver.CUdeviceptr><void_ptr>pdst
     else:
         pdst = int(CUdeviceptr(dst))
-        cdst = <ccuda.CUdeviceptr><void_ptr>pdst
-
-    err = ccuda.cuMemcpyAsync(cdst, csrc, ByteCount, chStream)
+        cydst = <cydriver.CUdeviceptr><void_ptr>pdst
+    err = cydriver.cuMemcpyAsync(cydst, cysrc, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -17997,57 +18603,52 @@ def cuMemcpyPeerAsync(dstDevice, dstContext, srcDevice, srcContext, size_t ByteC
     --------
     :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpy3DPeer`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cudaMemcpyPeerAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUcontext csrcContext
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUcontext cysrcContext
     if srcContext is None:
-        csrcContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(srcContext, (CUcontext)):
+        cysrcContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(srcContext, (CUcontext,)):
         psrcContext = int(srcContext)
-        csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
+        cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
     else:
         psrcContext = int(CUcontext(srcContext))
-        csrcContext = <ccuda.CUcontext><void_ptr>psrcContext
-
-    cdef ccuda.CUdeviceptr csrcDevice
+        cysrcContext = <cydriver.CUcontext><void_ptr>psrcContext
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdef ccuda.CUcontext cdstContext
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cdef cydriver.CUcontext cydstContext
     if dstContext is None:
-        cdstContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(dstContext, (CUcontext)):
+        cydstContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(dstContext, (CUcontext,)):
         pdstContext = int(dstContext)
-        cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
+        cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
     else:
         pdstContext = int(CUcontext(dstContext))
-        cdstContext = <ccuda.CUcontext><void_ptr>pdstContext
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cydstContext = <cydriver.CUcontext><void_ptr>pdstContext
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemcpyPeerAsync(cdstDevice, cdstContext, csrcDevice, csrcContext, ByteCount, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemcpyPeerAsync(cydstDevice, cydstContext, cysrcDevice, cysrcContext, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18081,29 +18682,27 @@ def cuMemcpyHtoDAsync(dstDevice, srcHost, size_t ByteCount, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    csrcHost = utils.HelperInputVoidPtr(srcHost)
-    cdef void* csrcHost_ptr = <void*><void_ptr>csrcHost.cptr
-    err = ccuda.cuMemcpyHtoDAsync(cdstDevice, csrcHost_ptr, ByteCount, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    cysrcHost = utils.HelperInputVoidPtr(srcHost)
+    cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
+    err = cydriver.cuMemcpyHtoDAsync(cydstDevice, cysrcHost_ptr, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18137,29 +18736,27 @@ def cuMemcpyDtoHAsync(dstHost, srcDevice, size_t ByteCount, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr csrcDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdstHost = utils.HelperInputVoidPtr(dstHost)
-    cdef void* cdstHost_ptr = <void*><void_ptr>cdstHost.cptr
-    err = ccuda.cuMemcpyDtoHAsync(cdstHost_ptr, csrcDevice, ByteCount, chStream)
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cydstHost = utils.HelperInputVoidPtr(dstHost)
+    cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
+    err = cydriver.cuMemcpyDtoHAsync(cydstHost_ptr, cysrcDevice, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18193,37 +18790,34 @@ def cuMemcpyDtoDAsync(dstDevice, srcDevice, size_t ByteCount, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr csrcDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(srcDevice, (CUdeviceptr)):
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(srcDevice, (CUdeviceptr,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
     else:
         psrcDevice = int(CUdeviceptr(srcDevice))
-        csrcDevice = <ccuda.CUdeviceptr><void_ptr>psrcDevice
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cysrcDevice = <cydriver.CUdeviceptr><void_ptr>psrcDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemcpyDtoDAsync(cdstDevice, csrcDevice, ByteCount, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemcpyDtoDAsync(cydstDevice, cysrcDevice, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18260,29 +18854,27 @@ def cuMemcpyHtoAAsync(dstArray, size_t dstOffset, srcHost, size_t ByteCount, hSt
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyToArrayAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUarray cdstArray
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUarray cydstArray
     if dstArray is None:
-        cdstArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(dstArray, (CUarray)):
+        cydstArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(dstArray, (CUarray,)):
         pdstArray = int(dstArray)
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
     else:
         pdstArray = int(CUarray(dstArray))
-        cdstArray = <ccuda.CUarray><void_ptr>pdstArray
-
-    csrcHost = utils.HelperInputVoidPtr(srcHost)
-    cdef void* csrcHost_ptr = <void*><void_ptr>csrcHost.cptr
-    err = ccuda.cuMemcpyHtoAAsync(cdstArray, dstOffset, csrcHost_ptr, ByteCount, chStream)
+        cydstArray = <cydriver.CUarray><void_ptr>pdstArray
+    cysrcHost = utils.HelperInputVoidPtr(srcHost)
+    cdef void* cysrcHost_ptr = <void*><void_ptr>cysrcHost.cptr
+    err = cydriver.cuMemcpyHtoAAsync(cydstArray, dstOffset, cysrcHost_ptr, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18319,29 +18911,27 @@ def cuMemcpyAtoHAsync(dstHost, srcArray, size_t srcOffset, size_t ByteCount, hSt
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpyFromArrayAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUarray csrcArray
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUarray cysrcArray
     if srcArray is None:
-        csrcArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(srcArray, (CUarray)):
+        cysrcArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(srcArray, (CUarray,)):
         psrcArray = int(srcArray)
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
     else:
         psrcArray = int(CUarray(srcArray))
-        csrcArray = <ccuda.CUarray><void_ptr>psrcArray
-
-    cdstHost = utils.HelperInputVoidPtr(dstHost)
-    cdef void* cdstHost_ptr = <void*><void_ptr>cdstHost.cptr
-    err = ccuda.cuMemcpyAtoHAsync(cdstHost_ptr, csrcArray, srcOffset, ByteCount, chStream)
+        cysrcArray = <cydriver.CUarray><void_ptr>psrcArray
+    cydstHost = utils.HelperInputVoidPtr(dstHost)
+    cdef void* cydstHost_ptr = <void*><void_ptr>cydstHost.cptr
+    err = cydriver.cuMemcpyAtoHAsync(cydstHost_ptr, cysrcArray, srcOffset, ByteCount, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18475,18 +19065,17 @@ def cuMemcpy2DAsync(pCopy : Optional[CUDA_MEMCPY2D], hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUDA_MEMCPY2D* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy2DAsync(cpCopy_ptr, chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUDA_MEMCPY2D* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy2DAsync(cypCopy_ptr, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18616,18 +19205,17 @@ def cuMemcpy3DAsync(pCopy : Optional[CUDA_MEMCPY3D], hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemcpy3DAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUDA_MEMCPY3D* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy3DAsync(cpCopy_ptr, chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUDA_MEMCPY3D* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy3DAsync(cypCopy_ptr, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18657,18 +19245,17 @@ def cuMemcpy3DPeerAsync(pCopy : Optional[CUDA_MEMCPY3D_PEER], hStream):
     --------
     :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyPeerAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUDA_MEMCPY3D_PEER* cpCopy_ptr = pCopy._ptr if pCopy != None else NULL
-    err = ccuda.cuMemcpy3DPeerAsync(cpCopy_ptr, chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUDA_MEMCPY3D_PEER* cypCopy_ptr = pCopy._ptr if pCopy != None else NULL
+    err = cydriver.cuMemcpy3DPeerAsync(cypCopy_ptr, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -18698,17 +19285,16 @@ def cuMemsetD8(dstDevice, unsigned char uc, size_t N):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD8(cdstDevice, uc, N)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD8(cydstDevice, uc, N)
     return (CUresult(err),)
 {{endif}}
 
@@ -18739,17 +19325,16 @@ def cuMemsetD16(dstDevice, unsigned short us, size_t N):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD16(cdstDevice, us, N)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD16(cydstDevice, us, N)
     return (CUresult(err),)
 {{endif}}
 
@@ -18780,17 +19365,16 @@ def cuMemsetD32(dstDevice, unsigned int ui, size_t N):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD32(cdstDevice, ui, N)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD32(cydstDevice, ui, N)
     return (CUresult(err),)
 {{endif}}
 
@@ -18828,17 +19412,16 @@ def cuMemsetD2D8(dstDevice, size_t dstPitch, unsigned char uc, size_t Width, siz
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2D`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D8(cdstDevice, dstPitch, uc, Width, Height)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D8(cydstDevice, dstPitch, uc, Width, Height)
     return (CUresult(err),)
 {{endif}}
 
@@ -18877,17 +19460,16 @@ def cuMemsetD2D16(dstDevice, size_t dstPitch, unsigned short us, size_t Width, s
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2D`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D16(cdstDevice, dstPitch, us, Width, Height)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D16(cydstDevice, dstPitch, us, Width, Height)
     return (CUresult(err),)
 {{endif}}
 
@@ -18926,17 +19508,16 @@ def cuMemsetD2D32(dstDevice, size_t dstPitch, unsigned int ui, size_t Width, siz
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2D`
     """
-    cdef ccuda.CUdeviceptr cdstDevice
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D32(cdstDevice, dstPitch, ui, Width, Height)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D32(cydstDevice, dstPitch, ui, Width, Height)
     return (CUresult(err),)
 {{endif}}
 
@@ -18968,27 +19549,25 @@ def cuMemsetD8Async(dstDevice, unsigned char uc, size_t N, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemsetAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD8Async(cdstDevice, uc, N, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD8Async(cydstDevice, uc, N, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19021,27 +19600,25 @@ def cuMemsetD16Async(dstDevice, unsigned short us, size_t N, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemsetAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD16Async(cdstDevice, us, N, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD16Async(cydstDevice, us, N, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19074,27 +19651,25 @@ def cuMemsetD32Async(dstDevice, unsigned int ui, size_t N, hStream):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMemsetAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD32Async(cdstDevice, ui, N, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD32Async(cydstDevice, ui, N, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19134,27 +19709,25 @@ def cuMemsetD2D8Async(dstDevice, size_t dstPitch, unsigned char uc, size_t Width
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2DAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D8Async(cdstDevice, dstPitch, uc, Width, Height, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D8Async(cydstDevice, dstPitch, uc, Width, Height, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19195,27 +19768,25 @@ def cuMemsetD2D16Async(dstDevice, size_t dstPitch, unsigned short us, size_t Wid
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD2D32Async`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2DAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D16Async(cdstDevice, dstPitch, us, Width, Height, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D16Async(cydstDevice, dstPitch, us, Width, Height, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19256,27 +19827,25 @@ def cuMemsetD2D32Async(dstDevice, size_t dstPitch, unsigned int ui, size_t Width
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cuMemsetD32Async`, :py:obj:`~.cudaMemset2DAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dstDevice, (CUdeviceptr)):
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dstDevice, (CUdeviceptr,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
     else:
         pdstDevice = int(CUdeviceptr(dstDevice))
-        cdstDevice = <ccuda.CUdeviceptr><void_ptr>pdstDevice
-
-    err = ccuda.cuMemsetD2D32Async(cdstDevice, dstPitch, ui, Width, Height, chStream)
+        cydstDevice = <cydriver.CUdeviceptr><void_ptr>pdstDevice
+    err = cydriver.cuMemsetD2D32Async(cydstDevice, dstPitch, ui, Width, Height, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -19343,8 +19912,8 @@ def cuArrayCreate(pAllocateArray : Optional[CUDA_ARRAY_DESCRIPTOR]):
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMallocArray`
     """
     cdef CUarray pHandle = CUarray()
-    cdef ccuda.CUDA_ARRAY_DESCRIPTOR* cpAllocateArray_ptr = pAllocateArray._ptr if pAllocateArray != None else NULL
-    err = ccuda.cuArrayCreate(pHandle._ptr, cpAllocateArray_ptr)
+    cdef cydriver.CUDA_ARRAY_DESCRIPTOR* cypAllocateArray_ptr = pAllocateArray._ptr if pAllocateArray != None else NULL
+    err = cydriver.cuArrayCreate(<cydriver.CUarray*>pHandle._ptr, cypAllocateArray_ptr)
     return (CUresult(err), pHandle)
 {{endif}}
 
@@ -19375,18 +19944,17 @@ def cuArrayGetDescriptor(hArray):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaArrayGetInfo`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUDA_ARRAY_DESCRIPTOR pArrayDescriptor = CUDA_ARRAY_DESCRIPTOR()
-    err = ccuda.cuArrayGetDescriptor(pArrayDescriptor._ptr, chArray)
+    err = cydriver.cuArrayGetDescriptor(<cydriver.CUDA_ARRAY_DESCRIPTOR*>pArrayDescriptor._ptr, cyhArray)
     return (CUresult(err), pArrayDescriptor)
 {{endif}}
 
@@ -19430,18 +19998,17 @@ def cuArrayGetSparseProperties(array):
     --------
     :py:obj:`~.cuMipmappedArrayGetSparseProperties`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccuda.CUarray carray
+    cdef cydriver.CUarray cyarray
     if array is None:
-        carray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(array, (CUarray)):
+        cyarray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(array, (CUarray,)):
         parray = int(array)
-        carray = <ccuda.CUarray><void_ptr>parray
+        cyarray = <cydriver.CUarray><void_ptr>parray
     else:
         parray = int(CUarray(array))
-        carray = <ccuda.CUarray><void_ptr>parray
-
+        cyarray = <cydriver.CUarray><void_ptr>parray
     cdef CUDA_ARRAY_SPARSE_PROPERTIES sparseProperties = CUDA_ARRAY_SPARSE_PROPERTIES()
-    err = ccuda.cuArrayGetSparseProperties(sparseProperties._ptr, carray)
+    err = cydriver.cuArrayGetSparseProperties(<cydriver.CUDA_ARRAY_SPARSE_PROPERTIES*>sparseProperties._ptr, cyarray)
     return (CUresult(err), sparseProperties)
 {{endif}}
 
@@ -19487,18 +20054,17 @@ def cuMipmappedArrayGetSparseProperties(mipmap):
     --------
     :py:obj:`~.cuArrayGetSparseProperties`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccuda.CUmipmappedArray cmipmap
+    cdef cydriver.CUmipmappedArray cymipmap
     if mipmap is None:
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>0
-    elif isinstance(mipmap, (CUmipmappedArray)):
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>0
+    elif isinstance(mipmap, (CUmipmappedArray,)):
         pmipmap = int(mipmap)
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     else:
         pmipmap = int(CUmipmappedArray(mipmap))
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
-
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     cdef CUDA_ARRAY_SPARSE_PROPERTIES sparseProperties = CUDA_ARRAY_SPARSE_PROPERTIES()
-    err = ccuda.cuMipmappedArrayGetSparseProperties(sparseProperties._ptr, cmipmap)
+    err = cydriver.cuMipmappedArrayGetSparseProperties(<cydriver.CUDA_ARRAY_SPARSE_PROPERTIES*>sparseProperties._ptr, cymipmap)
     return (CUresult(err), sparseProperties)
 {{endif}}
 
@@ -19536,28 +20102,26 @@ def cuArrayGetMemoryRequirements(array, device):
     --------
     :py:obj:`~.cuMipmappedArrayGetMemoryRequirements`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef ccuda.CUarray carray
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef cydriver.CUarray cyarray
     if array is None:
-        carray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(array, (CUarray)):
+        cyarray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(array, (CUarray,)):
         parray = int(array)
-        carray = <ccuda.CUarray><void_ptr>parray
+        cyarray = <cydriver.CUarray><void_ptr>parray
     else:
         parray = int(CUarray(array))
-        carray = <ccuda.CUarray><void_ptr>parray
-
+        cyarray = <cydriver.CUarray><void_ptr>parray
     cdef CUDA_ARRAY_MEMORY_REQUIREMENTS memoryRequirements = CUDA_ARRAY_MEMORY_REQUIREMENTS()
-    err = ccuda.cuArrayGetMemoryRequirements(memoryRequirements._ptr, carray, cdevice)
+    err = cydriver.cuArrayGetMemoryRequirements(<cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS*>memoryRequirements._ptr, cyarray, cydevice)
     return (CUresult(err), memoryRequirements)
 {{endif}}
 
@@ -19596,28 +20160,26 @@ def cuMipmappedArrayGetMemoryRequirements(mipmap, device):
     --------
     :py:obj:`~.cuArrayGetMemoryRequirements`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef ccuda.CUmipmappedArray cmipmap
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef cydriver.CUmipmappedArray cymipmap
     if mipmap is None:
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>0
-    elif isinstance(mipmap, (CUmipmappedArray)):
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>0
+    elif isinstance(mipmap, (CUmipmappedArray,)):
         pmipmap = int(mipmap)
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     else:
         pmipmap = int(CUmipmappedArray(mipmap))
-        cmipmap = <ccuda.CUmipmappedArray><void_ptr>pmipmap
-
+        cymipmap = <cydriver.CUmipmappedArray><void_ptr>pmipmap
     cdef CUDA_ARRAY_MEMORY_REQUIREMENTS memoryRequirements = CUDA_ARRAY_MEMORY_REQUIREMENTS()
-    err = ccuda.cuMipmappedArrayGetMemoryRequirements(memoryRequirements._ptr, cmipmap, cdevice)
+    err = cydriver.cuMipmappedArrayGetMemoryRequirements(<cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS*>memoryRequirements._ptr, cymipmap, cydevice)
     return (CUresult(err), memoryRequirements)
 {{endif}}
 
@@ -19661,18 +20223,17 @@ def cuArrayGetPlane(hArray, unsigned int planeIdx):
     --------
     :py:obj:`~.cuArrayCreate`, :py:obj:`~.cudaGetArrayPlane`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUarray pPlaneArray = CUarray()
-    err = ccuda.cuArrayGetPlane(pPlaneArray._ptr, chArray, planeIdx)
+    err = cydriver.cuArrayGetPlane(<cydriver.CUarray*>pPlaneArray._ptr, cyhArray, planeIdx)
     return (CUresult(err), pPlaneArray)
 {{endif}}
 
@@ -19698,17 +20259,16 @@ def cuArrayDestroy(hArray):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaFreeArray`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
-    err = ccuda.cuArrayDestroy(chArray)
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
+    err = cydriver.cuArrayDestroy(cyhArray)
     return (CUresult(err),)
 {{endif}}
 
@@ -19839,8 +20399,8 @@ def cuArray3DCreate(pAllocateArray : Optional[CUDA_ARRAY3D_DESCRIPTOR]):
     :py:obj:`~.cuArray3DGetDescriptor`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaMalloc3DArray`
     """
     cdef CUarray pHandle = CUarray()
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR* cpAllocateArray_ptr = pAllocateArray._ptr if pAllocateArray != None else NULL
-    err = ccuda.cuArray3DCreate(pHandle._ptr, cpAllocateArray_ptr)
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR* cypAllocateArray_ptr = pAllocateArray._ptr if pAllocateArray != None else NULL
+    err = cydriver.cuArray3DCreate(<cydriver.CUarray*>pHandle._ptr, cypAllocateArray_ptr)
     return (CUresult(err), pHandle)
 {{endif}}
 
@@ -19875,18 +20435,17 @@ def cuArray3DGetDescriptor(hArray):
     --------
     :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArrayDestroy`, :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemAllocPitch`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DAsync`, :py:obj:`~.cuMemcpy2DUnaligned`, :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuMemcpy3DAsync`, :py:obj:`~.cuMemcpyAtoA`, :py:obj:`~.cuMemcpyAtoD`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpyDtoA`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpyDtoDAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemGetAddressRange`, :py:obj:`~.cuMemGetInfo`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`, :py:obj:`~.cudaArrayGetInfo`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     cdef CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor = CUDA_ARRAY3D_DESCRIPTOR()
-    err = ccuda.cuArray3DGetDescriptor(pArrayDescriptor._ptr, chArray)
+    err = cydriver.cuArray3DGetDescriptor(<cydriver.CUDA_ARRAY3D_DESCRIPTOR*>pArrayDescriptor._ptr, cyhArray)
     return (CUresult(err), pArrayDescriptor)
 {{endif}}
 
@@ -20005,8 +20564,8 @@ def cuMipmappedArrayCreate(pMipmappedArrayDesc : Optional[CUDA_ARRAY3D_DESCRIPTO
     :py:obj:`~.cuMipmappedArrayDestroy`, :py:obj:`~.cuMipmappedArrayGetLevel`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cudaMallocMipmappedArray`
     """
     cdef CUmipmappedArray pHandle = CUmipmappedArray()
-    cdef ccuda.CUDA_ARRAY3D_DESCRIPTOR* cpMipmappedArrayDesc_ptr = pMipmappedArrayDesc._ptr if pMipmappedArrayDesc != None else NULL
-    err = ccuda.cuMipmappedArrayCreate(pHandle._ptr, cpMipmappedArrayDesc_ptr, numMipmapLevels)
+    cdef cydriver.CUDA_ARRAY3D_DESCRIPTOR* cypMipmappedArrayDesc_ptr = pMipmappedArrayDesc._ptr if pMipmappedArrayDesc != None else NULL
+    err = cydriver.cuMipmappedArrayCreate(<cydriver.CUmipmappedArray*>pHandle._ptr, cypMipmappedArrayDesc_ptr, numMipmapLevels)
     return (CUresult(err), pHandle)
 {{endif}}
 
@@ -20040,18 +20599,17 @@ def cuMipmappedArrayGetLevel(hMipmappedArray, unsigned int level):
     --------
     :py:obj:`~.cuMipmappedArrayCreate`, :py:obj:`~.cuMipmappedArrayDestroy`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cudaGetMipmappedArrayLevel`
     """
-    cdef ccuda.CUmipmappedArray chMipmappedArray
+    cdef cydriver.CUmipmappedArray cyhMipmappedArray
     if hMipmappedArray is None:
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>0
-    elif isinstance(hMipmappedArray, (CUmipmappedArray)):
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>0
+    elif isinstance(hMipmappedArray, (CUmipmappedArray,)):
         phMipmappedArray = int(hMipmappedArray)
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     else:
         phMipmappedArray = int(CUmipmappedArray(hMipmappedArray))
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
-
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     cdef CUarray pLevelArray = CUarray()
-    err = ccuda.cuMipmappedArrayGetLevel(pLevelArray._ptr, chMipmappedArray, level)
+    err = cydriver.cuMipmappedArrayGetLevel(<cydriver.CUarray*>pLevelArray._ptr, cyhMipmappedArray, level)
     return (CUresult(err), pLevelArray)
 {{endif}}
 
@@ -20077,17 +20635,16 @@ def cuMipmappedArrayDestroy(hMipmappedArray):
     --------
     :py:obj:`~.cuMipmappedArrayCreate`, :py:obj:`~.cuMipmappedArrayGetLevel`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cudaFreeMipmappedArray`
     """
-    cdef ccuda.CUmipmappedArray chMipmappedArray
+    cdef cydriver.CUmipmappedArray cyhMipmappedArray
     if hMipmappedArray is None:
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>0
-    elif isinstance(hMipmappedArray, (CUmipmappedArray)):
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>0
+    elif isinstance(hMipmappedArray, (CUmipmappedArray,)):
         phMipmappedArray = int(hMipmappedArray)
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     else:
         phMipmappedArray = int(CUmipmappedArray(hMipmappedArray))
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
-
-    err = ccuda.cuMipmappedArrayDestroy(chMipmappedArray)
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
+    err = cydriver.cuMipmappedArrayDestroy(cyhMipmappedArray)
     return (CUresult(err),)
 {{endif}}
 
@@ -20140,20 +20697,19 @@ def cuMemGetHandleForAddressRange(dptr, size_t size, handleType not None : CUmem
     handle : Any
         Pointer to the location where the returned handle will be stored.
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     cdef int handle = 0
-    cdef void* chandle_ptr = <void*>&handle
-    cdef ccuda.CUmemRangeHandleType chandleType = handleType.value
-    err = ccuda.cuMemGetHandleForAddressRange(chandle_ptr, cdptr, size, chandleType, flags)
+    cdef void* cyhandle_ptr = <void*>&handle
+    cdef cydriver.CUmemRangeHandleType cyhandleType = handleType.value
+    err = cydriver.cuMemGetHandleForAddressRange(cyhandle_ptr, cydptr, size, cyhandleType, flags)
     return (CUresult(err), handle)
 {{endif}}
 
@@ -20191,18 +20747,17 @@ def cuMemAddressReserve(size_t size, size_t alignment, addr, unsigned long long
     --------
     :py:obj:`~.cuMemAddressFree`
     """
-    cdef ccuda.CUdeviceptr caddr
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     cdef CUdeviceptr ptr = CUdeviceptr()
-    err = ccuda.cuMemAddressReserve(ptr._ptr, size, alignment, caddr, flags)
+    err = cydriver.cuMemAddressReserve(<cydriver.CUdeviceptr*>ptr._ptr, size, alignment, cyaddr, flags)
     return (CUresult(err), ptr)
 {{endif}}
 
@@ -20232,17 +20787,16 @@ def cuMemAddressFree(ptr, size_t size):
     --------
     :py:obj:`~.cuMemAddressReserve`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    err = ccuda.cuMemAddressFree(cptr, size)
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    err = cydriver.cuMemAddressFree(cyptr, size)
     return (CUresult(err),)
 {{endif}}
 
@@ -20293,8 +20847,8 @@ def cuMemCreate(size_t size, prop : Optional[CUmemAllocationProp], unsigned long
     :py:obj:`~.cuMemRelease`, :py:obj:`~.cuMemExportToShareableHandle`, :py:obj:`~.cuMemImportFromShareableHandle`
     """
     cdef CUmemGenericAllocationHandle handle = CUmemGenericAllocationHandle()
-    cdef ccuda.CUmemAllocationProp* cprop_ptr = prop._ptr if prop != None else NULL
-    err = ccuda.cuMemCreate(handle._ptr, size, cprop_ptr, flags)
+    cdef cydriver.CUmemAllocationProp* cyprop_ptr = prop._ptr if prop != None else NULL
+    err = cydriver.cuMemCreate(<cydriver.CUmemGenericAllocationHandle*>handle._ptr, size, cyprop_ptr, flags)
     return (CUresult(err), handle)
 {{endif}}
 
@@ -20329,17 +20883,16 @@ def cuMemRelease(handle):
     --------
     :py:obj:`~.cuMemCreate`
     """
-    cdef ccuda.CUmemGenericAllocationHandle chandle
+    cdef cydriver.CUmemGenericAllocationHandle cyhandle
     if handle is None:
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>0
-    elif isinstance(handle, (CUmemGenericAllocationHandle)):
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>0
+    elif isinstance(handle, (CUmemGenericAllocationHandle,)):
         phandle = int(handle)
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     else:
         phandle = int(CUmemGenericAllocationHandle(handle))
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
-
-    err = ccuda.cuMemRelease(chandle)
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
+    err = cydriver.cuMemRelease(cyhandle)
     return (CUresult(err),)
 {{endif}}
 
@@ -20392,34 +20945,32 @@ def cuMemMap(ptr, size_t size, size_t offset, handle, unsigned long long flags):
     --------
     :py:obj:`~.cuMemUnmap`, :py:obj:`~.cuMemSetAccess`, :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemAddressReserve`, :py:obj:`~.cuMemImportFromShareableHandle`
     """
-    cdef ccuda.CUmemGenericAllocationHandle chandle
+    cdef cydriver.CUmemGenericAllocationHandle cyhandle
     if handle is None:
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>0
-    elif isinstance(handle, (CUmemGenericAllocationHandle)):
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>0
+    elif isinstance(handle, (CUmemGenericAllocationHandle,)):
         phandle = int(handle)
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     else:
         phandle = int(CUmemGenericAllocationHandle(handle))
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
-
-    cdef ccuda.CUdeviceptr cptr
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    err = ccuda.cuMemMap(cptr, size, offset, chandle, flags)
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    err = cydriver.cuMemMap(cyptr, size, offset, cyhandle, flags)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuMemMapArrayAsync' in found_functions}}
 
 @cython.embedsignature(True)
-def cuMemMapArrayAsync(mapInfoList : Optional[List[CUarrayMapInfo]], unsigned int count, hStream):
+def cuMemMapArrayAsync(mapInfoList : Optional[Tuple[CUarrayMapInfo] | List[CUarrayMapInfo]], unsigned int count, hStream):
     """ Maps or unmaps subregions of sparse CUDA arrays and sparse CUDA mipmapped arrays.
 
     Performs map or unmap operations on subregions of sparse CUDA arrays
@@ -20562,32 +21113,29 @@ def cuMemMapArrayAsync(mapInfoList : Optional[List[CUarrayMapInfo]], unsigned in
     --------
     :py:obj:`~.cuMipmappedArrayCreate`, :py:obj:`~.cuArrayCreate`, :py:obj:`~.cuArray3DCreate`, :py:obj:`~.cuMemCreate`, :py:obj:`~.cuArrayGetSparseProperties`, :py:obj:`~.cuMipmappedArrayGetSparseProperties`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     mapInfoList = [] if mapInfoList is None else mapInfoList
-    if not all(isinstance(_x, (CUarrayMapInfo)) for _x in mapInfoList):
-        raise TypeError("Argument 'mapInfoList' is not instance of type (expected List[ccuda.CUarrayMapInfo]")
-
-    cdef ccuda.CUarrayMapInfo* cmapInfoList = NULL
+    if not all(isinstance(_x, (CUarrayMapInfo,)) for _x in mapInfoList):
+        raise TypeError("Argument 'mapInfoList' is not instance of type (expected Tuple[cydriver.CUarrayMapInfo,] or List[cydriver.CUarrayMapInfo,]")
+    cdef cydriver.CUarrayMapInfo* cymapInfoList = NULL
     if len(mapInfoList) > 0:
-        cmapInfoList = <ccuda.CUarrayMapInfo*> calloc(len(mapInfoList), sizeof(ccuda.CUarrayMapInfo))
-        if cmapInfoList is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(mapInfoList)) + 'x' + str(sizeof(ccuda.CUarrayMapInfo)))
+        cymapInfoList = <cydriver.CUarrayMapInfo*> calloc(len(mapInfoList), sizeof(cydriver.CUarrayMapInfo))
+        if cymapInfoList is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(mapInfoList)) + 'x' + str(sizeof(cydriver.CUarrayMapInfo)))
         for idx in range(len(mapInfoList)):
-            memcpy(&cmapInfoList[idx], (<CUarrayMapInfo>mapInfoList[idx])._ptr, sizeof(ccuda.CUarrayMapInfo))
-
+            string.memcpy(&cymapInfoList[idx], (<CUarrayMapInfo>mapInfoList[idx])._ptr, sizeof(cydriver.CUarrayMapInfo))
     if count > len(mapInfoList): raise RuntimeError("List is too small: " + str(len(mapInfoList)) + " < " + str(count))
-    err = ccuda.cuMemMapArrayAsync((<CUarrayMapInfo>mapInfoList[0])._ptr if len(mapInfoList) == 1 else cmapInfoList, count, chStream)
-    if cmapInfoList is not NULL:
-        free(cmapInfoList)
+    err = cydriver.cuMemMapArrayAsync((<CUarrayMapInfo>mapInfoList[0])._ptr if len(mapInfoList) == 1 else cymapInfoList, count, cyhStream)
+    if cymapInfoList is not NULL:
+        free(cymapInfoList)
     return (CUresult(err),)
 {{endif}}
 
@@ -20626,24 +21174,23 @@ def cuMemUnmap(ptr, size_t size):
     --------
     :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemAddressReserve`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    err = ccuda.cuMemUnmap(cptr, size)
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    err = cydriver.cuMemUnmap(cyptr, size)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuMemSetAccess' in found_functions}}
 
 @cython.embedsignature(True)
-def cuMemSetAccess(ptr, size_t size, desc : Optional[List[CUmemAccessDesc]], size_t count):
+def cuMemSetAccess(ptr, size_t size, desc : Optional[Tuple[CUmemAccessDesc] | List[CUmemAccessDesc]], size_t count):
     """ Set the access flags for each location specified in `desc` for the given virtual address range.
 
     Given the virtual address range via `ptr` and `size`, and the locations
@@ -20674,31 +21221,28 @@ def cuMemSetAccess(ptr, size_t size, desc : Optional[List[CUmemAccessDesc]], siz
     :py:obj:`~.cuMemSetAccess`, :py:obj:`~.cuMemCreate`, :py:obj:`~.py`:obj:`~.cuMemMap`
     """
     desc = [] if desc is None else desc
-    if not all(isinstance(_x, (CUmemAccessDesc)) for _x in desc):
-        raise TypeError("Argument 'desc' is not instance of type (expected List[ccuda.CUmemAccessDesc]")
-
-    cdef ccuda.CUdeviceptr cptr
+    if not all(isinstance(_x, (CUmemAccessDesc,)) for _x in desc):
+        raise TypeError("Argument 'desc' is not instance of type (expected Tuple[cydriver.CUmemAccessDesc,] or List[cydriver.CUmemAccessDesc,]")
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    cdef ccuda.CUmemAccessDesc* cdesc = NULL
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    cdef cydriver.CUmemAccessDesc* cydesc = NULL
     if len(desc) > 0:
-        cdesc = <ccuda.CUmemAccessDesc*> calloc(len(desc), sizeof(ccuda.CUmemAccessDesc))
-        if cdesc is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(desc)) + 'x' + str(sizeof(ccuda.CUmemAccessDesc)))
+        cydesc = <cydriver.CUmemAccessDesc*> calloc(len(desc), sizeof(cydriver.CUmemAccessDesc))
+        if cydesc is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(desc)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc)))
         for idx in range(len(desc)):
-            memcpy(&cdesc[idx], (<CUmemAccessDesc>desc[idx])._ptr, sizeof(ccuda.CUmemAccessDesc))
-
+            string.memcpy(&cydesc[idx], (<CUmemAccessDesc>desc[idx])._ptr, sizeof(cydriver.CUmemAccessDesc))
     if count > <size_t>len(desc): raise RuntimeError("List is too small: " + str(len(desc)) + " < " + str(count))
-    err = ccuda.cuMemSetAccess(cptr, size, (<CUmemAccessDesc>desc[0])._ptr if len(desc) == 1 else cdesc, count)
-    if cdesc is not NULL:
-        free(cdesc)
+    err = cydriver.cuMemSetAccess(cyptr, size, (<CUmemAccessDesc>desc[0])._ptr if len(desc) == 1 else cydesc, count)
+    if cydesc is not NULL:
+        free(cydesc)
     return (CUresult(err),)
 {{endif}}
 
@@ -20726,19 +21270,18 @@ def cuMemGetAccess(location : Optional[CUmemLocation], ptr):
     --------
     :py:obj:`~.cuMemSetAccess`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     cdef unsigned long long flags = 0
-    cdef ccuda.CUmemLocation* clocation_ptr = location._ptr if location != None else NULL
-    err = ccuda.cuMemGetAccess(&flags, clocation_ptr, cptr)
+    cdef cydriver.CUmemLocation* cylocation_ptr = location._ptr if location != None else NULL
+    err = cydriver.cuMemGetAccess(&flags, cylocation_ptr, cyptr)
     return (CUresult(err), flags)
 {{endif}}
 
@@ -20784,21 +21327,20 @@ def cuMemExportToShareableHandle(handle, handleType not None : CUmemAllocationHa
     --------
     :py:obj:`~.cuMemImportFromShareableHandle`
     """
-    cdef ccuda.CUmemGenericAllocationHandle chandle
+    cdef cydriver.CUmemGenericAllocationHandle cyhandle
     if handle is None:
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>0
-    elif isinstance(handle, (CUmemGenericAllocationHandle)):
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>0
+    elif isinstance(handle, (CUmemGenericAllocationHandle,)):
         phandle = int(handle)
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     else:
         phandle = int(CUmemGenericAllocationHandle(handle))
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
-
-    cdef utils.HelperCUmemAllocationHandleType cshareableHandle = utils.HelperCUmemAllocationHandleType(handleType)
-    cdef void* cshareableHandle_ptr = <void*><void_ptr>cshareableHandle.cptr
-    cdef ccuda.CUmemAllocationHandleType chandleType = handleType.value
-    err = ccuda.cuMemExportToShareableHandle(cshareableHandle_ptr, chandle, chandleType, flags)
-    return (CUresult(err), cshareableHandle.pyObj())
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
+    cdef utils.HelperCUmemAllocationHandleType cyshareableHandle = utils.HelperCUmemAllocationHandleType(handleType)
+    cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
+    cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
+    err = cydriver.cuMemExportToShareableHandle(cyshareableHandle_ptr, cyhandle, cyhandleType, flags)
+    return (CUresult(err), cyshareableHandle.pyObj())
 {{endif}}
 
 {{if 'cuMemImportFromShareableHandle' in found_functions}}
@@ -20835,10 +21377,10 @@ def cuMemImportFromShareableHandle(osHandle, shHandleType not None : CUmemAlloca
     Importing shareable handles exported from some graphics APIs(VUlkan, OpenGL, etc) created on devices under an SLI group may not be supported, and thus this API will return CUDA_ERROR_NOT_SUPPORTED. There is no guarantee that the contents of `handle` will be the same CUDA memory handle for the same given OS shareable handle, or the same underlying allocation.
     """
     cdef CUmemGenericAllocationHandle handle = CUmemGenericAllocationHandle()
-    cosHandle = utils.HelperInputVoidPtr(osHandle)
-    cdef void* cosHandle_ptr = <void*><void_ptr>cosHandle.cptr
-    cdef ccuda.CUmemAllocationHandleType cshHandleType = shHandleType.value
-    err = ccuda.cuMemImportFromShareableHandle(handle._ptr, cosHandle_ptr, cshHandleType)
+    cyosHandle = utils.HelperInputVoidPtr(osHandle)
+    cdef void* cyosHandle_ptr = <void*><void_ptr>cyosHandle.cptr
+    cdef cydriver.CUmemAllocationHandleType cyshHandleType = shHandleType.value
+    err = cydriver.cuMemImportFromShareableHandle(<cydriver.CUmemGenericAllocationHandle*>handle._ptr, cyosHandle_ptr, cyshHandleType)
     return (CUresult(err), handle)
 {{endif}}
 
@@ -20872,9 +21414,9 @@ def cuMemGetAllocationGranularity(prop : Optional[CUmemAllocationProp], option n
     :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemMap`
     """
     cdef size_t granularity = 0
-    cdef ccuda.CUmemAllocationProp* cprop_ptr = prop._ptr if prop != None else NULL
-    cdef ccuda.CUmemAllocationGranularity_flags coption = option.value
-    err = ccuda.cuMemGetAllocationGranularity(&granularity, cprop_ptr, coption)
+    cdef cydriver.CUmemAllocationProp* cyprop_ptr = prop._ptr if prop != None else NULL
+    cdef cydriver.CUmemAllocationGranularity_flags cyoption = option.value
+    err = cydriver.cuMemGetAllocationGranularity(&granularity, cyprop_ptr, cyoption)
     return (CUresult(err), granularity)
 {{endif}}
 
@@ -20901,18 +21443,17 @@ def cuMemGetAllocationPropertiesFromHandle(handle):
     --------
     :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemImportFromShareableHandle`
     """
-    cdef ccuda.CUmemGenericAllocationHandle chandle
+    cdef cydriver.CUmemGenericAllocationHandle cyhandle
     if handle is None:
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>0
-    elif isinstance(handle, (CUmemGenericAllocationHandle)):
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>0
+    elif isinstance(handle, (CUmemGenericAllocationHandle,)):
         phandle = int(handle)
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     else:
         phandle = int(CUmemGenericAllocationHandle(handle))
-        chandle = <ccuda.CUmemGenericAllocationHandle><void_ptr>phandle
-
+        cyhandle = <cydriver.CUmemGenericAllocationHandle><void_ptr>phandle
     cdef CUmemAllocationProp prop = CUmemAllocationProp()
-    err = ccuda.cuMemGetAllocationPropertiesFromHandle(prop._ptr, chandle)
+    err = cydriver.cuMemGetAllocationPropertiesFromHandle(<cydriver.CUmemAllocationProp*>prop._ptr, cyhandle)
     return (CUresult(err), prop)
 {{endif}}
 
@@ -20948,9 +21489,9 @@ def cuMemRetainAllocationHandle(addr):
     The address `addr`, can be any address in a range previously mapped by :py:obj:`~.cuMemMap`, and not necessarily the start address.
     """
     cdef CUmemGenericAllocationHandle handle = CUmemGenericAllocationHandle()
-    caddr = utils.HelperInputVoidPtr(addr)
-    cdef void* caddr_ptr = <void*><void_ptr>caddr.cptr
-    err = ccuda.cuMemRetainAllocationHandle(handle._ptr, caddr_ptr)
+    cyaddr = utils.HelperInputVoidPtr(addr)
+    cdef void* cyaddr_ptr = <void*><void_ptr>cyaddr.cptr
+    err = cydriver.cuMemRetainAllocationHandle(<cydriver.CUmemGenericAllocationHandle*>handle._ptr, cyaddr_ptr)
     return (CUresult(err), handle)
 {{endif}}
 
@@ -20981,27 +21522,25 @@ def cuMemFreeAsync(dptr, hStream):
     -----
     During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdeviceptr cdptr
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    err = ccuda.cuMemFreeAsync(cdptr, chStream)
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    err = cydriver.cuMemFreeAsync(cydptr, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -21043,18 +21582,17 @@ def cuMemAllocAsync(size_t bytesize, hStream):
 
     During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUdeviceptr dptr = CUdeviceptr()
-    err = ccuda.cuMemAllocAsync(dptr._ptr, bytesize, chStream)
+    err = cydriver.cuMemAllocAsync(<cydriver.CUdeviceptr*>dptr._ptr, bytesize, cyhStream)
     return (CUresult(err), dptr)
 {{endif}}
 
@@ -21095,17 +21633,16 @@ def cuMemPoolTrimTo(pool, size_t minBytesToKeep):
 
     : Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    err = ccuda.cuMemPoolTrimTo(cpool, minBytesToKeep)
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    err = cydriver.cuMemPoolTrimTo(cypool, minBytesToKeep)
     return (CUresult(err),)
 {{endif}}
 
@@ -21168,20 +21705,19 @@ def cuMemPoolSetAttribute(pool, attr not None : CUmemPool_attribute, value):
     --------
     :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuDeviceGetDefaultMemPool`, :py:obj:`~.cuDeviceGetMemPool`, :py:obj:`~.cuMemPoolCreate`
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    cdef ccuda.CUmemPool_attribute cattr = attr.value
-    cdef utils.HelperCUmemPool_attribute cvalue = utils.HelperCUmemPool_attribute(attr, value, is_getter=False)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccuda.cuMemPoolSetAttribute(cpool, cattr, cvalue_ptr)
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    cdef cydriver.CUmemPool_attribute cyattr = attr.value
+    cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, value, is_getter=False)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cydriver.cuMemPoolSetAttribute(cypool, cyattr, cyvalue_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -21251,27 +21787,26 @@ def cuMemPoolGetAttribute(pool, attr not None : CUmemPool_attribute):
     --------
     :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuDeviceGetDefaultMemPool`, :py:obj:`~.cuDeviceGetMemPool`, :py:obj:`~.cuMemPoolCreate`
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    cdef ccuda.CUmemPool_attribute cattr = attr.value
-    cdef utils.HelperCUmemPool_attribute cvalue = utils.HelperCUmemPool_attribute(attr, 0, is_getter=True)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccuda.cuMemPoolGetAttribute(cpool, cattr, cvalue_ptr)
-    return (CUresult(err), cvalue.pyObj())
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    cdef cydriver.CUmemPool_attribute cyattr = attr.value
+    cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, 0, is_getter=True)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cydriver.cuMemPoolGetAttribute(cypool, cyattr, cyvalue_ptr)
+    return (CUresult(err), cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuMemPoolSetAccess' in found_functions}}
 
 @cython.embedsignature(True)
-def cuMemPoolSetAccess(pool, map : Optional[List[CUmemAccessDesc]], size_t count):
+def cuMemPoolSetAccess(pool, map : Optional[Tuple[CUmemAccessDesc] | List[CUmemAccessDesc]], size_t count):
     """ Controls visibility of pools between devices.
 
     Parameters
@@ -21294,31 +21829,28 @@ def cuMemPoolSetAccess(pool, map : Optional[List[CUmemAccessDesc]], size_t count
     :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuDeviceGetDefaultMemPool`, :py:obj:`~.cuDeviceGetMemPool`, :py:obj:`~.cuMemPoolCreate`
     """
     map = [] if map is None else map
-    if not all(isinstance(_x, (CUmemAccessDesc)) for _x in map):
-        raise TypeError("Argument 'map' is not instance of type (expected List[ccuda.CUmemAccessDesc]")
-
-    cdef ccuda.CUmemoryPool cpool
+    if not all(isinstance(_x, (CUmemAccessDesc,)) for _x in map):
+        raise TypeError("Argument 'map' is not instance of type (expected Tuple[cydriver.CUmemAccessDesc,] or List[cydriver.CUmemAccessDesc,]")
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    cdef ccuda.CUmemAccessDesc* cmap = NULL
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    cdef cydriver.CUmemAccessDesc* cymap = NULL
     if len(map) > 0:
-        cmap = <ccuda.CUmemAccessDesc*> calloc(len(map), sizeof(ccuda.CUmemAccessDesc))
-        if cmap is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(map)) + 'x' + str(sizeof(ccuda.CUmemAccessDesc)))
+        cymap = <cydriver.CUmemAccessDesc*> calloc(len(map), sizeof(cydriver.CUmemAccessDesc))
+        if cymap is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(map)) + 'x' + str(sizeof(cydriver.CUmemAccessDesc)))
         for idx in range(len(map)):
-            memcpy(&cmap[idx], (<CUmemAccessDesc>map[idx])._ptr, sizeof(ccuda.CUmemAccessDesc))
-
+            string.memcpy(&cymap[idx], (<CUmemAccessDesc>map[idx])._ptr, sizeof(cydriver.CUmemAccessDesc))
     if count > <size_t>len(map): raise RuntimeError("List is too small: " + str(len(map)) + " < " + str(count))
-    err = ccuda.cuMemPoolSetAccess(cpool, (<CUmemAccessDesc>map[0])._ptr if len(map) == 1 else cmap, count)
-    if cmap is not NULL:
-        free(cmap)
+    err = cydriver.cuMemPoolSetAccess(cypool, (<CUmemAccessDesc>map[0])._ptr if len(map) == 1 else cymap, count)
+    if cymap is not NULL:
+        free(cymap)
     return (CUresult(err),)
 {{endif}}
 
@@ -21349,19 +21881,18 @@ def cuMemPoolGetAccess(memPool, location : Optional[CUmemLocation]):
     --------
     :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuDeviceGetDefaultMemPool`, :py:obj:`~.cuDeviceGetMemPool`, :py:obj:`~.cuMemPoolCreate`
     """
-    cdef ccuda.CUmemoryPool cmemPool
+    cdef cydriver.CUmemoryPool cymemPool
     if memPool is None:
-        cmemPool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(memPool, (CUmemoryPool)):
+        cymemPool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(memPool, (CUmemoryPool,)):
         pmemPool = int(memPool)
-        cmemPool = <ccuda.CUmemoryPool><void_ptr>pmemPool
+        cymemPool = <cydriver.CUmemoryPool><void_ptr>pmemPool
     else:
         pmemPool = int(CUmemoryPool(memPool))
-        cmemPool = <ccuda.CUmemoryPool><void_ptr>pmemPool
-
-    cdef ccuda.CUmemAccess_flags flags
-    cdef ccuda.CUmemLocation* clocation_ptr = location._ptr if location != None else NULL
-    err = ccuda.cuMemPoolGetAccess(&flags, cmemPool, clocation_ptr)
+        cymemPool = <cydriver.CUmemoryPool><void_ptr>pmemPool
+    cdef cydriver.CUmemAccess_flags flags
+    cdef cydriver.CUmemLocation* cylocation_ptr = location._ptr if location != None else NULL
+    err = cydriver.cuMemPoolGetAccess(&flags, cymemPool, cylocation_ptr)
     return (CUresult(err), CUmemAccess_flags(flags))
 {{endif}}
 
@@ -21399,8 +21930,8 @@ def cuMemPoolCreate(poolProps : Optional[CUmemPoolProps]):
     Specifying CU_MEM_HANDLE_TYPE_NONE creates a memory pool that will not support IPC.
     """
     cdef CUmemoryPool pool = CUmemoryPool()
-    cdef ccuda.CUmemPoolProps* cpoolProps_ptr = poolProps._ptr if poolProps != None else NULL
-    err = ccuda.cuMemPoolCreate(pool._ptr, cpoolProps_ptr)
+    cdef cydriver.CUmemPoolProps* cypoolProps_ptr = poolProps._ptr if poolProps != None else NULL
+    err = cydriver.cuMemPoolCreate(<cydriver.CUmemoryPool*>pool._ptr, cypoolProps_ptr)
     return (CUresult(err), pool)
 {{endif}}
 
@@ -21437,17 +21968,16 @@ def cuMemPoolDestroy(pool):
     -----
     A device's default memory pool cannot be destroyed.
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    err = ccuda.cuMemPoolDestroy(cpool)
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    err = cydriver.cuMemPoolDestroy(cypool)
     return (CUresult(err),)
 {{endif}}
 
@@ -21486,28 +22016,26 @@ def cuMemAllocFromPoolAsync(size_t bytesize, pool, hStream):
     -----
     During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUmemoryPool cpool
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     cdef CUdeviceptr dptr = CUdeviceptr()
-    err = ccuda.cuMemAllocFromPoolAsync(dptr._ptr, bytesize, cpool, chStream)
+    err = cydriver.cuMemAllocFromPoolAsync(<cydriver.CUdeviceptr*>dptr._ptr, bytesize, cypool, cyhStream)
     return (CUresult(err), dptr)
 {{endif}}
 
@@ -21550,21 +22078,20 @@ def cuMemPoolExportToShareableHandle(pool, handleType not None : CUmemAllocation
     -----
     : To create an IPC capable mempool, create a mempool with a CUmemAllocationHandleType other than CU_MEM_HANDLE_TYPE_NONE.
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
-    cdef utils.HelperCUmemAllocationHandleType chandle_out = utils.HelperCUmemAllocationHandleType(handleType)
-    cdef void* chandle_out_ptr = <void*><void_ptr>chandle_out.cptr
-    cdef ccuda.CUmemAllocationHandleType chandleType = handleType.value
-    err = ccuda.cuMemPoolExportToShareableHandle(chandle_out_ptr, cpool, chandleType, flags)
-    return (CUresult(err), chandle_out.pyObj())
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
+    cdef utils.HelperCUmemAllocationHandleType cyhandle_out = utils.HelperCUmemAllocationHandleType(handleType)
+    cdef void* cyhandle_out_ptr = <void*><void_ptr>cyhandle_out.cptr
+    cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
+    err = cydriver.cuMemPoolExportToShareableHandle(cyhandle_out_ptr, cypool, cyhandleType, flags)
+    return (CUresult(err), cyhandle_out.pyObj())
 {{endif}}
 
 {{if 'cuMemPoolImportFromShareableHandle' in found_functions}}
@@ -21601,10 +22128,10 @@ def cuMemPoolImportFromShareableHandle(handle, handleType not None : CUmemAlloca
     Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in cuDeviceSetMemPool or :py:obj:`~.cuMemAllocFromPoolAsync` calls.
     """
     cdef CUmemoryPool pool_out = CUmemoryPool()
-    chandle = utils.HelperInputVoidPtr(handle)
-    cdef void* chandle_ptr = <void*><void_ptr>chandle.cptr
-    cdef ccuda.CUmemAllocationHandleType chandleType = handleType.value
-    err = ccuda.cuMemPoolImportFromShareableHandle(pool_out._ptr, chandle_ptr, chandleType, flags)
+    cyhandle = utils.HelperInputVoidPtr(handle)
+    cdef void* cyhandle_ptr = <void*><void_ptr>cyhandle.cptr
+    cdef cydriver.CUmemAllocationHandleType cyhandleType = handleType.value
+    err = cydriver.cuMemPoolImportFromShareableHandle(<cydriver.CUmemoryPool*>pool_out._ptr, cyhandle_ptr, cyhandleType, flags)
     return (CUresult(err), pool_out)
 {{endif}}
 
@@ -21635,18 +22162,17 @@ def cuMemPoolExportPointer(ptr):
     --------
     :py:obj:`~.cuMemPoolExportToShareableHandle`, :py:obj:`~.cuMemPoolImportFromShareableHandle`, :py:obj:`~.cuMemPoolImportPointer`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     cdef CUmemPoolPtrExportData shareData_out = CUmemPoolPtrExportData()
-    err = ccuda.cuMemPoolExportPointer(shareData_out._ptr, cptr)
+    err = cydriver.cuMemPoolExportPointer(<cydriver.CUmemPoolPtrExportData*>shareData_out._ptr, cyptr)
     return (CUresult(err), shareData_out)
 {{endif}}
 
@@ -21686,19 +22212,18 @@ def cuMemPoolImportPointer(pool, shareData : Optional[CUmemPoolPtrExportData]):
     -----
     The cuMemFreeAsync api may be used in the exporting process before the cuMemFreeAsync operation completes in its stream as long as the cuMemFreeAsync in the exporting process specifies a stream with a stream dependency on the importing process's cuMemFreeAsync.
     """
-    cdef ccuda.CUmemoryPool cpool
+    cdef cydriver.CUmemoryPool cypool
     if pool is None:
-        cpool = <ccuda.CUmemoryPool><void_ptr>0
-    elif isinstance(pool, (CUmemoryPool)):
+        cypool = <cydriver.CUmemoryPool><void_ptr>0
+    elif isinstance(pool, (CUmemoryPool,)):
         ppool = int(pool)
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     else:
         ppool = int(CUmemoryPool(pool))
-        cpool = <ccuda.CUmemoryPool><void_ptr>ppool
-
+        cypool = <cydriver.CUmemoryPool><void_ptr>ppool
     cdef CUdeviceptr ptr_out = CUdeviceptr()
-    cdef ccuda.CUmemPoolPtrExportData* cshareData_ptr = shareData._ptr if shareData != None else NULL
-    err = ccuda.cuMemPoolImportPointer(ptr_out._ptr, cpool, cshareData_ptr)
+    cdef cydriver.CUmemPoolPtrExportData* cyshareData_ptr = shareData._ptr if shareData != None else NULL
+    err = cydriver.cuMemPoolImportPointer(<cydriver.CUdeviceptr*>ptr_out._ptr, cypool, cyshareData_ptr)
     return (CUresult(err), ptr_out)
 {{endif}}
 
@@ -21891,21 +22416,20 @@ def cuPointerGetAttribute(attribute not None : CUpointer_attribute, ptr):
     --------
     :py:obj:`~.cuPointerSetAttribute`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuMemHostUnregister`, :py:obj:`~.cudaPointerGetAttributes`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    cdef utils.HelperCUpointer_attribute cdata = utils.HelperCUpointer_attribute(attribute, 0, is_getter=True)
-    cdef void* cdata_ptr = <void*><void_ptr>cdata.cptr
-    cdef ccuda.CUpointer_attribute cattribute = attribute.value
-    err = ccuda.cuPointerGetAttribute(cdata_ptr, cattribute, cptr)
-    return (CUresult(err), cdata.pyObj())
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    cdef utils.HelperCUpointer_attribute cydata = utils.HelperCUpointer_attribute(attribute, 0, is_getter=True)
+    cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
+    cdef cydriver.CUpointer_attribute cyattribute = attribute.value
+    err = cydriver.cuPointerGetAttribute(cydata_ptr, cyattribute, cyptr)
+    return (CUresult(err), cydata.pyObj())
 {{endif}}
 
 {{if 'cuMemPrefetchAsync' in found_functions}}
@@ -21990,37 +22514,34 @@ def cuMemPrefetchAsync(devPtr, size_t count, dstDevice, hStream):
     --------
     :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cudaMemPrefetchAsync`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUdevice cdstDevice
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUdevice cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdevice>0
-    elif isinstance(dstDevice, (CUdevice)):
+        cydstDevice = <cydriver.CUdevice>0
+    elif isinstance(dstDevice, (CUdevice,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdevice>pdstDevice
+        cydstDevice = <cydriver.CUdevice>pdstDevice
     else:
         pdstDevice = int(CUdevice(dstDevice))
-        cdstDevice = <ccuda.CUdevice>pdstDevice
-
-    cdef ccuda.CUdeviceptr cdevPtr
+        cydstDevice = <cydriver.CUdevice>pdstDevice
+    cdef cydriver.CUdeviceptr cydevPtr
     if devPtr is None:
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(devPtr, (CUdeviceptr)):
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(devPtr, (CUdeviceptr,)):
         pdevPtr = int(devPtr)
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     else:
         pdevPtr = int(CUdeviceptr(devPtr))
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-
-    err = ccuda.cuMemPrefetchAsync(cdevPtr, count, cdstDevice, chStream)
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
+    err = cydriver.cuMemPrefetchAsync(cydevPtr, count, cydstDevice, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -22187,28 +22708,26 @@ def cuMemAdvise(devPtr, size_t count, advice not None : CUmem_advise, device):
     --------
     :py:obj:`~.cuMemcpy`, :py:obj:`~.cuMemcpyPeer`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cudaMemAdvise`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef ccuda.CUdeviceptr cdevPtr
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef cydriver.CUdeviceptr cydevPtr
     if devPtr is None:
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(devPtr, (CUdeviceptr)):
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(devPtr, (CUdeviceptr,)):
         pdevPtr = int(devPtr)
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     else:
         pdevPtr = int(CUdeviceptr(devPtr))
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-
-    cdef ccuda.CUmem_advise cadvice = advice.value
-    err = ccuda.cuMemAdvise(cdevPtr, count, cadvice, cdevice)
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
+    cdef cydriver.CUmem_advise cyadvice = advice.value
+    err = cydriver.cuMemAdvise(cydevPtr, count, cyadvice, cydevice)
     return (CUresult(err),)
 {{endif}}
 
@@ -22295,27 +22814,26 @@ def cuMemRangeGetAttribute(size_t dataSize, attribute not None : CUmem_range_att
     --------
     :py:obj:`~.cuMemRangeGetAttributes`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cudaMemRangeGetAttribute`
     """
-    cdef ccuda.CUdeviceptr cdevPtr
+    cdef cydriver.CUdeviceptr cydevPtr
     if devPtr is None:
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(devPtr, (CUdeviceptr)):
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(devPtr, (CUdeviceptr,)):
         pdevPtr = int(devPtr)
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     else:
         pdevPtr = int(CUdeviceptr(devPtr))
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-
-    cdef utils.HelperCUmem_range_attribute cdata = utils.HelperCUmem_range_attribute(attribute, dataSize)
-    cdef void* cdata_ptr = <void*><void_ptr>cdata.cptr
-    cdef ccuda.CUmem_range_attribute cattribute = attribute.value
-    err = ccuda.cuMemRangeGetAttribute(cdata_ptr, dataSize, cattribute, cdevPtr, count)
-    return (CUresult(err), cdata.pyObj())
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
+    cdef utils.HelperCUmem_range_attribute cydata = utils.HelperCUmem_range_attribute(attribute, dataSize)
+    cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
+    cdef cydriver.CUmem_range_attribute cyattribute = attribute.value
+    err = cydriver.cuMemRangeGetAttribute(cydata_ptr, dataSize, cyattribute, cydevPtr, count)
+    return (CUresult(err), cydata.pyObj())
 {{endif}}
 
 {{if 'cuMemRangeGetAttributes' in found_functions}}
 
 @cython.embedsignature(True)
-def cuMemRangeGetAttributes(dataSizes : List[int], attributes : Optional[List[CUmem_range_attribute]], size_t numAttributes, devPtr, size_t count):
+def cuMemRangeGetAttributes(dataSizes : Tuple[int] | List[int], attributes : Optional[Tuple[CUmem_range_attribute] | List[CUmem_range_attribute]], size_t numAttributes, devPtr, size_t count):
     """ Query attributes of a given memory range.
 
     Query attributes of the memory range starting at `devPtr` with a size
@@ -22364,31 +22882,28 @@ def cuMemRangeGetAttributes(dataSizes : List[int], attributes : Optional[List[CU
     --------
     :py:obj:`~.cuMemRangeGetAttribute`, :py:obj:`~.cuMemAdvise`, :py:obj:`~.cuMemPrefetchAsync`, :py:obj:`~.cudaMemRangeGetAttributes`
     """
-    cdef ccuda.CUdeviceptr cdevPtr
+    cdef cydriver.CUdeviceptr cydevPtr
     if devPtr is None:
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(devPtr, (CUdeviceptr)):
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(devPtr, (CUdeviceptr,)):
         pdevPtr = int(devPtr)
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     else:
         pdevPtr = int(CUdeviceptr(devPtr))
-        cdevPtr = <ccuda.CUdeviceptr><void_ptr>pdevPtr
-
+        cydevPtr = <cydriver.CUdeviceptr><void_ptr>pdevPtr
     attributes = [] if attributes is None else attributes
     if not all(isinstance(_x, (CUmem_range_attribute)) for _x in attributes):
-        raise TypeError("Argument 'attributes' is not instance of type (expected List[ccuda.CUmem_range_attribute]")
-
+        raise TypeError("Argument 'attributes' is not instance of type (expected Tuple[cydriver.CUmem_range_attribute] or List[cydriver.CUmem_range_attribute]")
     if not all(isinstance(_x, (int)) for _x in dataSizes):
-        raise TypeError("Argument 'dataSizes' is not instance of type (expected List[int]")
-
+        raise TypeError("Argument 'dataSizes' is not instance of type (expected Tuple[int] or List[int]")
     pylist = [utils.HelperCUmem_range_attribute(pyattributes, pydataSizes) for (pyattributes, pydataSizes) in zip(attributes, dataSizes)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    cdef void** cvoidStarHelper_ptr = <void**><void_ptr>voidStarHelper.cptr
-    cdef vector[size_t] cdataSizes = dataSizes
-    cdef vector[ccuda.CUmem_range_attribute] cattributes = [pyattributes.value for pyattributes in (attributes)]
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperdata = utils.InputVoidPtrPtrHelper(pylist)
+    cdef void** cyvoidStarHelper_ptr = <void**><void_ptr>voidStarHelperdata.cptr
+    cdef vector[size_t] cydataSizes = dataSizes
+    cdef vector[cydriver.CUmem_range_attribute] cyattributes = [pyattributes.value for pyattributes in (attributes)]
     if numAttributes > <size_t>len(dataSizes): raise RuntimeError("List is too small: " + str(len(dataSizes)) + " < " + str(numAttributes))
     if numAttributes > <size_t>len(attributes): raise RuntimeError("List is too small: " + str(len(attributes)) + " < " + str(numAttributes))
-    err = ccuda.cuMemRangeGetAttributes(cvoidStarHelper_ptr, cdataSizes.data(), cattributes.data(), numAttributes, cdevPtr, count)
+    err = cydriver.cuMemRangeGetAttributes(cyvoidStarHelper_ptr, cydataSizes.data(), cyattributes.data(), numAttributes, cydevPtr, count)
     return (CUresult(err), [obj.pyObj() for obj in pylist])
 {{endif}}
 
@@ -22432,27 +22947,26 @@ def cuPointerSetAttribute(value, attribute not None : CUpointer_attribute, ptr):
     --------
     :py:obj:`~.cuPointerGetAttribute`, :py:obj:`~.cuPointerGetAttributes`, :py:obj:`~.cuMemAlloc`, :py:obj:`~.cuMemFree`, :py:obj:`~.cuMemAllocHost`, :py:obj:`~.cuMemFreeHost`, :py:obj:`~.cuMemHostAlloc`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuMemHostUnregister`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
-    cdef utils.HelperCUpointer_attribute cvalue = utils.HelperCUpointer_attribute(attribute, value, is_getter=False)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    cdef ccuda.CUpointer_attribute cattribute = attribute.value
-    err = ccuda.cuPointerSetAttribute(cvalue_ptr, cattribute, cptr)
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
+    cdef utils.HelperCUpointer_attribute cyvalue = utils.HelperCUpointer_attribute(attribute, value, is_getter=False)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    cdef cydriver.CUpointer_attribute cyattribute = attribute.value
+    err = cydriver.cuPointerSetAttribute(cyvalue_ptr, cyattribute, cyptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuPointerGetAttributes' in found_functions}}
 
 @cython.embedsignature(True)
-def cuPointerGetAttributes(unsigned int numAttributes, attributes : Optional[List[CUpointer_attribute]], ptr):
+def cuPointerGetAttributes(unsigned int numAttributes, attributes : Optional[Tuple[CUpointer_attribute] | List[CUpointer_attribute]], ptr):
     """ Returns information about a pointer.
 
     The supported attributes are (refer to
@@ -22518,26 +23032,24 @@ def cuPointerGetAttributes(unsigned int numAttributes, attributes : Optional[Lis
     --------
     :py:obj:`~.cuPointerGetAttribute`, :py:obj:`~.cuPointerSetAttribute`, :py:obj:`~.cudaPointerGetAttributes`
     """
-    cdef ccuda.CUdeviceptr cptr
+    cdef cydriver.CUdeviceptr cyptr
     if ptr is None:
-        cptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(ptr, (CUdeviceptr)):
+        cyptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(ptr, (CUdeviceptr,)):
         pptr = int(ptr)
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     else:
         pptr = int(CUdeviceptr(ptr))
-        cptr = <ccuda.CUdeviceptr><void_ptr>pptr
-
+        cyptr = <cydriver.CUdeviceptr><void_ptr>pptr
     attributes = [] if attributes is None else attributes
     if not all(isinstance(_x, (CUpointer_attribute)) for _x in attributes):
-        raise TypeError("Argument 'attributes' is not instance of type (expected List[ccuda.CUpointer_attribute]")
-
+        raise TypeError("Argument 'attributes' is not instance of type (expected Tuple[cydriver.CUpointer_attribute] or List[cydriver.CUpointer_attribute]")
     if numAttributes > len(attributes): raise RuntimeError("List is too small: " + str(len(attributes)) + " < " + str(numAttributes))
-    cdef vector[ccuda.CUpointer_attribute] cattributes = [pyattributes.value for pyattributes in (attributes)]
+    cdef vector[cydriver.CUpointer_attribute] cyattributes = [pyattributes.value for pyattributes in (attributes)]
     pylist = [utils.HelperCUpointer_attribute(pyattributes, 0, is_getter=True) for pyattributes in attributes]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    cdef void** cvoidStarHelper_ptr = <void**><void_ptr>voidStarHelper.cptr
-    err = ccuda.cuPointerGetAttributes(numAttributes, cattributes.data(), cvoidStarHelper_ptr, cptr)
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperdata = utils.InputVoidPtrPtrHelper(pylist)
+    cdef void** cyvoidStarHelper_ptr = <void**><void_ptr>voidStarHelperdata.cptr
+    err = cydriver.cuPointerGetAttributes(numAttributes, cyattributes.data(), cyvoidStarHelper_ptr, cyptr)
     return (CUresult(err), [obj.pyObj() for obj in pylist])
 {{endif}}
 
@@ -22576,7 +23088,7 @@ def cuStreamCreate(unsigned int Flags):
     :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`
     """
     cdef CUstream phStream = CUstream()
-    err = ccuda.cuStreamCreate(phStream._ptr, Flags)
+    err = cydriver.cuStreamCreate(<cydriver.CUstream*>phStream._ptr, Flags)
     return (CUresult(err), phStream)
 {{endif}}
 
@@ -22627,7 +23139,7 @@ def cuStreamCreateWithPriority(unsigned int flags, int priority):
     In the current implementation, only compute kernels launched in priority streams are affected by the stream's priority. Stream priorities have no effect on host-to-device and device-to-host memory operations.
     """
     cdef CUstream phStream = CUstream()
-    err = ccuda.cuStreamCreateWithPriority(phStream._ptr, flags, priority)
+    err = cydriver.cuStreamCreateWithPriority(<cydriver.CUstream*>phStream._ptr, flags, priority)
     return (CUresult(err), phStream)
 {{endif}}
 
@@ -22662,18 +23174,17 @@ def cuStreamGetPriority(hStream):
     --------
     :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cudaStreamGetPriority`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef int priority = 0
-    err = ccuda.cuStreamGetPriority(chStream, &priority)
+    err = cydriver.cuStreamGetPriority(cyhStream, &priority)
     return (CUresult(err), priority)
 {{endif}}
 
@@ -22705,18 +23216,17 @@ def cuStreamGetFlags(hStream):
     --------
     :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cudaStreamGetFlags`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef unsigned int flags = 0
-    err = ccuda.cuStreamGetFlags(chStream, &flags)
+    err = cydriver.cuStreamGetFlags(cyhStream, &flags)
     return (CUresult(err), flags)
 {{endif}}
 
@@ -22764,18 +23274,17 @@ def cuStreamGetCtx(hStream):
     --------
     :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamCreateWithPriority`, :py:obj:`~.cuStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUcontext pctx = CUcontext()
-    err = ccuda.cuStreamGetCtx(chStream, pctx._ptr)
+    err = cydriver.cuStreamGetCtx(cyhStream, <cydriver.CUcontext*>pctx._ptr)
     return (CUresult(err), pctx)
 {{endif}}
 
@@ -22817,27 +23326,25 @@ def cuStreamWaitEvent(hStream, hEvent, unsigned int Flags):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cudaStreamWaitEvent`
     """
-    cdef ccuda.CUevent chEvent
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    cdef ccuda.CUstream chStream
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    err = ccuda.cuStreamWaitEvent(chStream, chEvent, Flags)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    err = cydriver.cuStreamWaitEvent(cyhStream, cyhEvent, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -22912,29 +23419,27 @@ def cuStreamAddCallback(hStream, callback, userData, unsigned int flags):
     -----
     This function is slated for eventual deprecation and removal. If you do not require the callback to execute in case of a device error, consider using :py:obj:`~.cuLaunchHostFunc`. Additionally, this function is not supported with :py:obj:`~.cuStreamBeginCapture` and :py:obj:`~.cuStreamEndCapture`, unlike :py:obj:`~.cuLaunchHostFunc`.
     """
-    cdef ccuda.CUstreamCallback ccallback
+    cdef cydriver.CUstreamCallback cycallback
     if callback is None:
-        ccallback = <ccuda.CUstreamCallback><void_ptr>0
-    elif isinstance(callback, (CUstreamCallback)):
+        cycallback = <cydriver.CUstreamCallback><void_ptr>0
+    elif isinstance(callback, (CUstreamCallback,)):
         pcallback = int(callback)
-        ccallback = <ccuda.CUstreamCallback><void_ptr>pcallback
+        cycallback = <cydriver.CUstreamCallback><void_ptr>pcallback
     else:
         pcallback = int(CUstreamCallback(callback))
-        ccallback = <ccuda.CUstreamCallback><void_ptr>pcallback
-
-    cdef ccuda.CUstream chStream
+        cycallback = <cydriver.CUstreamCallback><void_ptr>pcallback
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cuserData = utils.HelperInputVoidPtr(userData)
-    cdef void* cuserData_ptr = <void*><void_ptr>cuserData.cptr
-    err = ccuda.cuStreamAddCallback(chStream, ccallback, cuserData_ptr, flags)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cyuserData = utils.HelperInputVoidPtr(userData)
+    cdef void* cyuserData_ptr = <void*><void_ptr>cyuserData.cptr
+    err = cydriver.cuStreamAddCallback(cyhStream, cycallback, cyuserData_ptr, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -22980,18 +23485,17 @@ def cuStreamBeginCapture(hStream, mode not None : CUstreamCaptureMode):
     -----
     Kernels captured using this API must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamCaptureMode cmode = mode.value
-    err = ccuda.cuStreamBeginCapture(chStream, cmode)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamCaptureMode cymode = mode.value
+    err = cydriver.cuStreamBeginCapture(cyhStream, cymode)
     return (CUresult(err),)
 {{endif}}
 
@@ -23061,9 +23565,9 @@ def cuThreadExchangeStreamCaptureMode(mode not None : CUstreamCaptureMode):
     --------
     :py:obj:`~.cuStreamBeginCapture`
     """
-    cdef ccuda.CUstreamCaptureMode cmode = mode.value
-    err = ccuda.cuThreadExchangeStreamCaptureMode(&cmode)
-    return (CUresult(err), CUstreamCaptureMode(cmode))
+    cdef cydriver.CUstreamCaptureMode cymode = mode.value
+    err = cydriver.cuThreadExchangeStreamCaptureMode(&cymode)
+    return (CUresult(err), CUstreamCaptureMode(cymode))
 {{endif}}
 
 {{if 'cuStreamEndCapture' in found_functions}}
@@ -23098,18 +23602,17 @@ def cuStreamEndCapture(hStream):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamIsCapturing`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     cdef CUgraph phGraph = CUgraph()
-    err = ccuda.cuStreamEndCapture(chStream, phGraph._ptr)
+    err = cydriver.cuStreamEndCapture(cyhStream, <cydriver.CUgraph*>phGraph._ptr)
     return (CUresult(err), phGraph)
 {{endif}}
 
@@ -23160,18 +23663,17 @@ def cuStreamIsCapturing(hStream):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamEndCapture`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamCaptureStatus captureStatus
-    err = ccuda.cuStreamIsCapturing(chStream, &captureStatus)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamCaptureStatus captureStatus
+    err = cydriver.cuStreamIsCapturing(cyhStream, &captureStatus)
     return (CUresult(err), CUstreamCaptureStatus(captureStatus))
 {{endif}}
 
@@ -23216,19 +23718,18 @@ def cuStreamGetCaptureInfo(hStream):
     --------
     :py:obj:`~.cuStreamGetCaptureInfo_v2`, :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamIsCapturing`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamCaptureStatus captureStatus_out
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamCaptureStatus captureStatus_out
     cdef cuuint64_t id_out = cuuint64_t()
-    err = ccuda.cuStreamGetCaptureInfo(chStream, &captureStatus_out, id_out._ptr)
+    err = cydriver.cuStreamGetCaptureInfo(cyhStream, &captureStatus_out, <cydriver.cuuint64_t*>id_out._ptr)
     return (CUresult(err), CUstreamCaptureStatus(captureStatus_out), id_out)
 {{endif}}
 
@@ -23299,32 +23800,31 @@ def cuStreamGetCaptureInfo_v2(hStream):
     --------
     :py:obj:`~.cuStreamGetCaptureInfo`, :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamIsCapturing`, :py:obj:`~.cuStreamUpdateCaptureDependencies`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamCaptureStatus captureStatus_out
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamCaptureStatus captureStatus_out
     cdef cuuint64_t id_out = cuuint64_t()
     cdef CUgraph graph_out = CUgraph()
-    cdef const ccuda.CUgraphNode* cdependencies_out = NULL
+    cdef const cydriver.CUgraphNode* cydependencies_out = NULL
     pydependencies_out = []
     cdef size_t numDependencies_out = 0
-    err = ccuda.cuStreamGetCaptureInfo_v2(chStream, &captureStatus_out, id_out._ptr, graph_out._ptr, &cdependencies_out, &numDependencies_out)
+    err = cydriver.cuStreamGetCaptureInfo_v2(cyhStream, &captureStatus_out, <cydriver.cuuint64_t*>id_out._ptr, <cydriver.CUgraph*>graph_out._ptr, &cydependencies_out, &numDependencies_out)
     if CUresult(err) == CUresult(0):
-        pydependencies_out = [CUgraphNode(init_value=<void_ptr>cdependencies_out[idx]) for idx in range(numDependencies_out)]
+        pydependencies_out = [CUgraphNode(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
     return (CUresult(err), CUstreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
 {{endif}}
 
 {{if 'cuStreamUpdateCaptureDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cuStreamUpdateCaptureDependencies(hStream, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, unsigned int flags):
+def cuStreamUpdateCaptureDependencies(hStream, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, unsigned int flags):
     """ Update the set of dependencies in a capturing stream (11.3+)
 
     Modifies the dependency set of a capturing stream. The dependency set
@@ -23369,32 +23869,29 @@ def cuStreamUpdateCaptureDependencies(hStream, dependencies : Optional[List[CUgr
     :py:obj:`~.cuStreamBeginCapture`, :py:obj:`~.cuStreamGetCaptureInfo`, :py:obj:`~.cuStreamGetCaptureInfo_v2`
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUstream chStream
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuStreamUpdateCaptureDependencies(chStream, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, flags)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuStreamUpdateCaptureDependencies(cyhStream, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, flags)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err),)
 {{endif}}
 
@@ -23490,27 +23987,25 @@ def cuStreamAttachMemAsync(hStream, dptr, size_t length, unsigned int flags):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuMemAllocManaged`, :py:obj:`~.cudaStreamAttachMemAsync`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    cdef ccuda.CUstream chStream
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    err = ccuda.cuStreamAttachMemAsync(chStream, cdptr, length, flags)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    err = cydriver.cuStreamAttachMemAsync(cyhStream, cydptr, length, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -23542,17 +24037,16 @@ def cuStreamQuery(hStream):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamQuery`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    err = ccuda.cuStreamQuery(chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    err = cydriver.cuStreamQuery(cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -23583,17 +24077,16 @@ def cuStreamSynchronize(hStream):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamSynchronize`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    err = ccuda.cuStreamSynchronize(chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    err = cydriver.cuStreamSynchronize(cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -23625,17 +24118,16 @@ def cuStreamDestroy(hStream):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    err = ccuda.cuStreamDestroy(chStream)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    err = cydriver.cuStreamDestroy(cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -23664,27 +24156,25 @@ def cuStreamCopyAttributes(dst, src):
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUstream csrc
+    cdef cydriver.CUstream cysrc
     if src is None:
-        csrc = <ccuda.CUstream><void_ptr>0
-    elif isinstance(src, (CUstream)):
+        cysrc = <cydriver.CUstream><void_ptr>0
+    elif isinstance(src, (CUstream,)):
         psrc = int(src)
-        csrc = <ccuda.CUstream><void_ptr>psrc
+        cysrc = <cydriver.CUstream><void_ptr>psrc
     else:
         psrc = int(CUstream(src))
-        csrc = <ccuda.CUstream><void_ptr>psrc
-
-    cdef ccuda.CUstream cdst
+        cysrc = <cydriver.CUstream><void_ptr>psrc
+    cdef cydriver.CUstream cydst
     if dst is None:
-        cdst = <ccuda.CUstream><void_ptr>0
-    elif isinstance(dst, (CUstream)):
+        cydst = <cydriver.CUstream><void_ptr>0
+    elif isinstance(dst, (CUstream,)):
         pdst = int(dst)
-        cdst = <ccuda.CUstream><void_ptr>pdst
+        cydst = <cydriver.CUstream><void_ptr>pdst
     else:
         pdst = int(CUstream(dst))
-        cdst = <ccuda.CUstream><void_ptr>pdst
-
-    err = ccuda.cuStreamCopyAttributes(cdst, csrc)
+        cydst = <cydriver.CUstream><void_ptr>pdst
+    err = cydriver.cuStreamCopyAttributes(cydst, cysrc)
     return (CUresult(err),)
 {{endif}}
 
@@ -23715,19 +24205,18 @@ def cuStreamGetAttribute(hStream, attr not None : CUstreamAttrID):
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamAttrID cattr = attr.value
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamAttrID cyattr = attr.value
     cdef CUstreamAttrValue value_out = CUstreamAttrValue()
-    err = ccuda.cuStreamGetAttribute(chStream, cattr, value_out._ptr)
+    err = cydriver.cuStreamGetAttribute(cyhStream, cyattr, <cydriver.CUstreamAttrValue*>value_out._ptr)
     return (CUresult(err), value_out)
 {{endif}}
 
@@ -23759,19 +24248,18 @@ def cuStreamSetAttribute(hStream, attr not None : CUstreamAttrID, value : Option
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUstreamAttrID cattr = attr.value
-    cdef ccuda.CUstreamAttrValue* cvalue_ptr = value._ptr if value != None else NULL
-    err = ccuda.cuStreamSetAttribute(chStream, cattr, cvalue_ptr)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUstreamAttrID cyattr = attr.value
+    cdef cydriver.CUstreamAttrValue* cyvalue_ptr = value._ptr if value != None else NULL
+    err = cydriver.cuStreamSetAttribute(cyhStream, cyattr, cyvalue_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -23819,7 +24307,7 @@ def cuEventCreate(unsigned int Flags):
     :py:obj:`~.cuEventRecord`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cudaEventCreate`, :py:obj:`~.cudaEventCreateWithFlags`
     """
     cdef CUevent phEvent = CUevent()
-    err = ccuda.cuEventCreate(phEvent._ptr, Flags)
+    err = cydriver.cuEventCreate(<cydriver.CUevent*>phEvent._ptr, Flags)
     return (CUresult(err), phEvent)
 {{endif}}
 
@@ -23861,27 +24349,25 @@ def cuEventRecord(hEvent, hStream):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cuEventRecordWithFlags`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUevent chEvent
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    err = ccuda.cuEventRecord(chEvent, chStream)
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    err = cydriver.cuEventRecord(cyhEvent, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -23933,27 +24419,25 @@ def cuEventRecordWithFlags(hEvent, hStream, unsigned int flags):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cudaEventRecord`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUevent chEvent
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    err = ccuda.cuEventRecordWithFlags(chEvent, chStream, flags)
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    err = cydriver.cuEventRecordWithFlags(cyhEvent, cyhStream, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -23989,17 +24473,16 @@ def cuEventQuery(hEvent):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cudaEventQuery`
     """
-    cdef ccuda.CUevent chEvent
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    err = ccuda.cuEventQuery(chEvent)
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    err = cydriver.cuEventQuery(cyhEvent)
     return (CUresult(err),)
 {{endif}}
 
@@ -24034,17 +24517,16 @@ def cuEventSynchronize(hEvent):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cudaEventSynchronize`
     """
-    cdef ccuda.CUevent chEvent
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    err = ccuda.cuEventSynchronize(chEvent)
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    err = cydriver.cuEventSynchronize(cyhEvent)
     return (CUresult(err),)
 {{endif}}
 
@@ -24076,17 +24558,16 @@ def cuEventDestroy(hEvent):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventElapsedTime`, :py:obj:`~.cudaEventDestroy`
     """
-    cdef ccuda.CUevent chEvent
+    cdef cydriver.CUevent cyhEvent
     if hEvent is None:
-        chEvent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEvent, (CUevent)):
+        cyhEvent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEvent, (CUevent,)):
         phEvent = int(hEvent)
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
     else:
         phEvent = int(CUevent(hEvent))
-        chEvent = <ccuda.CUevent><void_ptr>phEvent
-
-    err = ccuda.cuEventDestroy(chEvent)
+        cyhEvent = <cydriver.CUevent><void_ptr>phEvent
+    err = cydriver.cuEventDestroy(cyhEvent)
     return (CUresult(err),)
 {{endif}}
 
@@ -24135,28 +24616,26 @@ def cuEventElapsedTime(hStart, hEnd):
     --------
     :py:obj:`~.cuEventCreate`, :py:obj:`~.cuEventRecord`, :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventDestroy`, :py:obj:`~.cudaEventElapsedTime`
     """
-    cdef ccuda.CUevent chEnd
+    cdef cydriver.CUevent cyhEnd
     if hEnd is None:
-        chEnd = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hEnd, (CUevent)):
+        cyhEnd = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hEnd, (CUevent,)):
         phEnd = int(hEnd)
-        chEnd = <ccuda.CUevent><void_ptr>phEnd
+        cyhEnd = <cydriver.CUevent><void_ptr>phEnd
     else:
         phEnd = int(CUevent(hEnd))
-        chEnd = <ccuda.CUevent><void_ptr>phEnd
-
-    cdef ccuda.CUevent chStart
+        cyhEnd = <cydriver.CUevent><void_ptr>phEnd
+    cdef cydriver.CUevent cyhStart
     if hStart is None:
-        chStart = <ccuda.CUevent><void_ptr>0
-    elif isinstance(hStart, (CUevent)):
+        cyhStart = <cydriver.CUevent><void_ptr>0
+    elif isinstance(hStart, (CUevent,)):
         phStart = int(hStart)
-        chStart = <ccuda.CUevent><void_ptr>phStart
+        cyhStart = <cydriver.CUevent><void_ptr>phStart
     else:
         phStart = int(CUevent(hStart))
-        chStart = <ccuda.CUevent><void_ptr>phStart
-
+        cyhStart = <cydriver.CUevent><void_ptr>phStart
     cdef float pMilliseconds = 0
-    err = ccuda.cuEventElapsedTime(&pMilliseconds, chStart, chEnd)
+    err = cydriver.cuEventElapsedTime(&pMilliseconds, cyhStart, cyhEnd)
     return (CUresult(err), pMilliseconds)
 {{endif}}
 
@@ -24308,8 +24787,8 @@ def cuImportExternalMemory(memHandleDesc : Optional[CUDA_EXTERNAL_MEMORY_HANDLE_
     and Cache Control" chapter from Vulkan specification.
     """
     cdef CUexternalMemory extMem_out = CUexternalMemory()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC* cmemHandleDesc_ptr = memHandleDesc._ptr if memHandleDesc != None else NULL
-    err = ccuda.cuImportExternalMemory(extMem_out._ptr, cmemHandleDesc_ptr)
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC* cymemHandleDesc_ptr = memHandleDesc._ptr if memHandleDesc != None else NULL
+    err = cydriver.cuImportExternalMemory(<cydriver.CUexternalMemory*>extMem_out._ptr, cymemHandleDesc_ptr)
     return (CUresult(err), extMem_out)
 {{endif}}
 
@@ -24366,19 +24845,18 @@ def cuExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[CUDA_EXTERNAL_
     --------
     :py:obj:`~.cuImportExternalMemory`, :py:obj:`~.cuDestroyExternalMemory`, :py:obj:`~.cuExternalMemoryGetMappedMipmappedArray`
     """
-    cdef ccuda.CUexternalMemory cextMem
+    cdef cydriver.CUexternalMemory cyextMem
     if extMem is None:
-        cextMem = <ccuda.CUexternalMemory><void_ptr>0
-    elif isinstance(extMem, (CUexternalMemory)):
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>0
+    elif isinstance(extMem, (CUexternalMemory,)):
         pextMem = int(extMem)
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     else:
         pextMem = int(CUexternalMemory(extMem))
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
-
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     cdef CUdeviceptr devPtr = CUdeviceptr()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC* cbufferDesc_ptr = bufferDesc._ptr if bufferDesc != None else NULL
-    err = ccuda.cuExternalMemoryGetMappedBuffer(devPtr._ptr, cextMem, cbufferDesc_ptr)
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC* cybufferDesc_ptr = bufferDesc._ptr if bufferDesc != None else NULL
+    err = cydriver.cuExternalMemoryGetMappedBuffer(<cydriver.CUdeviceptr*>devPtr._ptr, cyextMem, cybufferDesc_ptr)
     return (CUresult(err), devPtr)
 {{endif}}
 
@@ -24442,19 +24920,18 @@ def cuExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[CUDA_E
     -----
     On Tegra devices, this API will always attempt to do a compressed mapping when the `extMem` is imported from a handle of type :py:obj:`~.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD`
     """
-    cdef ccuda.CUexternalMemory cextMem
+    cdef cydriver.CUexternalMemory cyextMem
     if extMem is None:
-        cextMem = <ccuda.CUexternalMemory><void_ptr>0
-    elif isinstance(extMem, (CUexternalMemory)):
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>0
+    elif isinstance(extMem, (CUexternalMemory,)):
         pextMem = int(extMem)
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     else:
         pextMem = int(CUexternalMemory(extMem))
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
-
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     cdef CUmipmappedArray mipmap = CUmipmappedArray()
-    cdef ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* cmipmapDesc_ptr = mipmapDesc._ptr if mipmapDesc != None else NULL
-    err = ccuda.cuExternalMemoryGetMappedMipmappedArray(mipmap._ptr, cextMem, cmipmapDesc_ptr)
+    cdef cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC* cymipmapDesc_ptr = mipmapDesc._ptr if mipmapDesc != None else NULL
+    err = cydriver.cuExternalMemoryGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>mipmap._ptr, cyextMem, cymipmapDesc_ptr)
     return (CUresult(err), mipmap)
 {{endif}}
 
@@ -24483,17 +24960,16 @@ def cuDestroyExternalMemory(extMem):
     --------
     :py:obj:`~.cuImportExternalMemory`, :py:obj:`~.cuExternalMemoryGetMappedBuffer`, :py:obj:`~.cuExternalMemoryGetMappedMipmappedArray`
     """
-    cdef ccuda.CUexternalMemory cextMem
+    cdef cydriver.CUexternalMemory cyextMem
     if extMem is None:
-        cextMem = <ccuda.CUexternalMemory><void_ptr>0
-    elif isinstance(extMem, (CUexternalMemory)):
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>0
+    elif isinstance(extMem, (CUexternalMemory,)):
         pextMem = int(extMem)
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
     else:
         pextMem = int(CUexternalMemory(extMem))
-        cextMem = <ccuda.CUexternalMemory><void_ptr>pextMem
-
-    err = ccuda.cuDestroyExternalMemory(cextMem)
+        cyextMem = <cydriver.CUexternalMemory><void_ptr>pextMem
+    err = cydriver.cuDestroyExternalMemory(cyextMem)
     return (CUresult(err),)
 {{endif}}
 
@@ -24640,15 +25116,15 @@ def cuImportExternalSemaphore(semHandleDesc : Optional[CUDA_EXTERNAL_SEMAPHORE_H
     :py:obj:`~.cuDestroyExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
     cdef CUexternalSemaphore extSem_out = CUexternalSemaphore()
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* csemHandleDesc_ptr = semHandleDesc._ptr if semHandleDesc != None else NULL
-    err = ccuda.cuImportExternalSemaphore(extSem_out._ptr, csemHandleDesc_ptr)
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC* cysemHandleDesc_ptr = semHandleDesc._ptr if semHandleDesc != None else NULL
+    err = cydriver.cuImportExternalSemaphore(<cydriver.CUexternalSemaphore*>extSem_out._ptr, cysemHandleDesc_ptr)
     return (CUresult(err), extSem_out)
 {{endif}}
 
 {{if 'cuSignalExternalSemaphoresAsync' in found_functions}}
 
 @cython.embedsignature(True)
-def cuSignalExternalSemaphoresAsync(extSemArray : Optional[List[CUexternalSemaphore]], paramsArray : Optional[List[CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS]], unsigned int numExtSems, stream):
+def cuSignalExternalSemaphoresAsync(extSemArray : Optional[Tuple[CUexternalSemaphore] | List[CUexternalSemaphore]], paramsArray : Optional[Tuple[CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS] | List[CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS]], unsigned int numExtSems, stream):
     """ Signals a set of external semaphore objects.
 
     Enqueues a signal operation on a set of externally allocated semaphore
@@ -24722,55 +25198,50 @@ def cuSignalExternalSemaphoresAsync(extSemArray : Optional[List[CUexternalSemaph
     --------
     :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuDestroyExternalSemaphore`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUstream cstream
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
+        cystream = <cydriver.CUstream><void_ptr>pstream
     paramsArray = [] if paramsArray is None else paramsArray
-    if not all(isinstance(_x, (CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS)) for _x in paramsArray):
-        raise TypeError("Argument 'paramsArray' is not instance of type (expected List[ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS]")
-
+    if not all(isinstance(_x, (CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,)) for _x in paramsArray):
+        raise TypeError("Argument 'paramsArray' is not instance of type (expected Tuple[cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,] or List[cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS,]")
     extSemArray = [] if extSemArray is None else extSemArray
-    if not all(isinstance(_x, (CUexternalSemaphore)) for _x in extSemArray):
-        raise TypeError("Argument 'extSemArray' is not instance of type (expected List[ccuda.CUexternalSemaphore]")
-
-    cdef ccuda.CUexternalSemaphore* cextSemArray = NULL
+    if not all(isinstance(_x, (CUexternalSemaphore,)) for _x in extSemArray):
+        raise TypeError("Argument 'extSemArray' is not instance of type (expected Tuple[cydriver.CUexternalSemaphore,] or List[cydriver.CUexternalSemaphore,]")
+    cdef cydriver.CUexternalSemaphore* cyextSemArray = NULL
     if len(extSemArray) > 0:
-        cextSemArray = <ccuda.CUexternalSemaphore*> calloc(len(extSemArray), sizeof(ccuda.CUexternalSemaphore))
-        if cextSemArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(ccuda.CUexternalSemaphore)))
+        cyextSemArray = <cydriver.CUexternalSemaphore*> calloc(len(extSemArray), sizeof(cydriver.CUexternalSemaphore))
+        if cyextSemArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(cydriver.CUexternalSemaphore)))
         else:
             for idx in range(len(extSemArray)):
-                cextSemArray[idx] = (<CUexternalSemaphore>extSemArray[idx])._ptr[0]
-
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* cparamsArray = NULL
+                cyextSemArray[idx] = <cydriver.CUexternalSemaphore>(<CUexternalSemaphore>extSemArray[idx])._ptr[0]
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS* cyparamsArray = NULL
     if len(paramsArray) > 0:
-        cparamsArray = <ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*> calloc(len(paramsArray), sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
-        if cparamsArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS)))
+        cyparamsArray = <cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS*> calloc(len(paramsArray), sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
+        if cyparamsArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS)))
         for idx in range(len(paramsArray)):
-            memcpy(&cparamsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>paramsArray[idx])._ptr, sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
-
+            string.memcpy(&cyparamsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>paramsArray[idx])._ptr, sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS))
     if numExtSems > len(extSemArray): raise RuntimeError("List is too small: " + str(len(extSemArray)) + " < " + str(numExtSems))
     if numExtSems > len(paramsArray): raise RuntimeError("List is too small: " + str(len(paramsArray)) + " < " + str(numExtSems))
-    err = ccuda.cuSignalExternalSemaphoresAsync((<CUexternalSemaphore>extSemArray[0])._ptr if len(extSemArray) == 1 else cextSemArray, (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>paramsArray[0])._ptr if len(paramsArray) == 1 else cparamsArray, numExtSems, cstream)
-    if cextSemArray is not NULL:
-        free(cextSemArray)
-    if cparamsArray is not NULL:
-        free(cparamsArray)
+    err = cydriver.cuSignalExternalSemaphoresAsync(<cydriver.CUexternalSemaphore*>(<CUexternalSemaphore>extSemArray[0])._ptr if len(extSemArray) == 1 else cyextSemArray, (<CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS>paramsArray[0])._ptr if len(paramsArray) == 1 else cyparamsArray, numExtSems, cystream)
+    if cyextSemArray is not NULL:
+        free(cyextSemArray)
+    if cyparamsArray is not NULL:
+        free(cyparamsArray)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuWaitExternalSemaphoresAsync' in found_functions}}
 
 @cython.embedsignature(True)
-def cuWaitExternalSemaphoresAsync(extSemArray : Optional[List[CUexternalSemaphore]], paramsArray : Optional[List[CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS]], unsigned int numExtSems, stream):
+def cuWaitExternalSemaphoresAsync(extSemArray : Optional[Tuple[CUexternalSemaphore] | List[CUexternalSemaphore]], paramsArray : Optional[Tuple[CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS] | List[CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS]], unsigned int numExtSems, stream):
     """ Waits on a set of external semaphore objects.
 
     Enqueues a wait operation on a set of externally allocated semaphore
@@ -24853,48 +25324,43 @@ def cuWaitExternalSemaphoresAsync(extSemArray : Optional[List[CUexternalSemaphor
     --------
     :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuDestroyExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`
     """
-    cdef ccuda.CUstream cstream
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
+        cystream = <cydriver.CUstream><void_ptr>pstream
     paramsArray = [] if paramsArray is None else paramsArray
-    if not all(isinstance(_x, (CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS)) for _x in paramsArray):
-        raise TypeError("Argument 'paramsArray' is not instance of type (expected List[ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS]")
-
+    if not all(isinstance(_x, (CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,)) for _x in paramsArray):
+        raise TypeError("Argument 'paramsArray' is not instance of type (expected Tuple[cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,] or List[cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS,]")
     extSemArray = [] if extSemArray is None else extSemArray
-    if not all(isinstance(_x, (CUexternalSemaphore)) for _x in extSemArray):
-        raise TypeError("Argument 'extSemArray' is not instance of type (expected List[ccuda.CUexternalSemaphore]")
-
-    cdef ccuda.CUexternalSemaphore* cextSemArray = NULL
+    if not all(isinstance(_x, (CUexternalSemaphore,)) for _x in extSemArray):
+        raise TypeError("Argument 'extSemArray' is not instance of type (expected Tuple[cydriver.CUexternalSemaphore,] or List[cydriver.CUexternalSemaphore,]")
+    cdef cydriver.CUexternalSemaphore* cyextSemArray = NULL
     if len(extSemArray) > 0:
-        cextSemArray = <ccuda.CUexternalSemaphore*> calloc(len(extSemArray), sizeof(ccuda.CUexternalSemaphore))
-        if cextSemArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(ccuda.CUexternalSemaphore)))
+        cyextSemArray = <cydriver.CUexternalSemaphore*> calloc(len(extSemArray), sizeof(cydriver.CUexternalSemaphore))
+        if cyextSemArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(cydriver.CUexternalSemaphore)))
         else:
             for idx in range(len(extSemArray)):
-                cextSemArray[idx] = (<CUexternalSemaphore>extSemArray[idx])._ptr[0]
-
-    cdef ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* cparamsArray = NULL
+                cyextSemArray[idx] = <cydriver.CUexternalSemaphore>(<CUexternalSemaphore>extSemArray[idx])._ptr[0]
+    cdef cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS* cyparamsArray = NULL
     if len(paramsArray) > 0:
-        cparamsArray = <ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*> calloc(len(paramsArray), sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
-        if cparamsArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS)))
+        cyparamsArray = <cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS*> calloc(len(paramsArray), sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
+        if cyparamsArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS)))
         for idx in range(len(paramsArray)):
-            memcpy(&cparamsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>paramsArray[idx])._ptr, sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
-
+            string.memcpy(&cyparamsArray[idx], (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>paramsArray[idx])._ptr, sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS))
     if numExtSems > len(extSemArray): raise RuntimeError("List is too small: " + str(len(extSemArray)) + " < " + str(numExtSems))
     if numExtSems > len(paramsArray): raise RuntimeError("List is too small: " + str(len(paramsArray)) + " < " + str(numExtSems))
-    err = ccuda.cuWaitExternalSemaphoresAsync((<CUexternalSemaphore>extSemArray[0])._ptr if len(extSemArray) == 1 else cextSemArray, (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>paramsArray[0])._ptr if len(paramsArray) == 1 else cparamsArray, numExtSems, cstream)
-    if cextSemArray is not NULL:
-        free(cextSemArray)
-    if cparamsArray is not NULL:
-        free(cparamsArray)
+    err = cydriver.cuWaitExternalSemaphoresAsync(<cydriver.CUexternalSemaphore*>(<CUexternalSemaphore>extSemArray[0])._ptr if len(extSemArray) == 1 else cyextSemArray, (<CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS>paramsArray[0])._ptr if len(paramsArray) == 1 else cyparamsArray, numExtSems, cystream)
+    if cyextSemArray is not NULL:
+        free(cyextSemArray)
+    if cyparamsArray is not NULL:
+        free(cyparamsArray)
     return (CUresult(err),)
 {{endif}}
 
@@ -24922,17 +25388,16 @@ def cuDestroyExternalSemaphore(extSem):
     --------
     :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUexternalSemaphore cextSem
+    cdef cydriver.CUexternalSemaphore cyextSem
     if extSem is None:
-        cextSem = <ccuda.CUexternalSemaphore><void_ptr>0
-    elif isinstance(extSem, (CUexternalSemaphore)):
+        cyextSem = <cydriver.CUexternalSemaphore><void_ptr>0
+    elif isinstance(extSem, (CUexternalSemaphore,)):
         pextSem = int(extSem)
-        cextSem = <ccuda.CUexternalSemaphore><void_ptr>pextSem
+        cyextSem = <cydriver.CUexternalSemaphore><void_ptr>pextSem
     else:
         pextSem = int(CUexternalSemaphore(extSem))
-        cextSem = <ccuda.CUexternalSemaphore><void_ptr>pextSem
-
-    err = ccuda.cuDestroyExternalSemaphore(cextSem)
+        cyextSem = <cydriver.CUexternalSemaphore><void_ptr>pextSem
+    err = cydriver.cuDestroyExternalSemaphore(cyextSem)
     return (CUresult(err),)
 {{endif}}
 
@@ -24984,37 +25449,34 @@ def cuStreamWaitValue32(stream, addr, value, unsigned int flags):
     -----
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
-    cdef ccuda.cuuint32_t cvalue
+    cdef cydriver.cuuint32_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint32_t><void_ptr>0
-    elif isinstance(value, (cuuint32_t)):
+        cyvalue = <cydriver.cuuint32_t><void_ptr>0
+    elif isinstance(value, (cuuint32_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint32_t(value))
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWaitValue32(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWaitValue32(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25061,37 +25523,34 @@ def cuStreamWaitValue64(stream, addr, value, unsigned int flags):
     -----
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
-    cdef ccuda.cuuint64_t cvalue
+    cdef cydriver.cuuint64_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint64_t><void_ptr>0
-    elif isinstance(value, (cuuint64_t)):
+        cyvalue = <cydriver.cuuint64_t><void_ptr>0
+    elif isinstance(value, (cuuint64_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint64_t(value))
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWaitValue64(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWaitValue64(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25135,37 +25594,34 @@ def cuStreamWriteValue32(stream, addr, value, unsigned int flags):
     --------
     :py:obj:`~.cuStreamWriteValue64`, :py:obj:`~.cuStreamWaitValue32`, :py:obj:`~.cuStreamWaitValue64`, :py:obj:`~.cuStreamBatchMemOp`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuEventRecord`
     """
-    cdef ccuda.cuuint32_t cvalue
+    cdef cydriver.cuuint32_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint32_t><void_ptr>0
-    elif isinstance(value, (cuuint32_t)):
+        cyvalue = <cydriver.cuuint32_t><void_ptr>0
+    elif isinstance(value, (cuuint32_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint32_t(value))
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWriteValue32(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWriteValue32(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25208,44 +25664,41 @@ def cuStreamWriteValue64(stream, addr, value, unsigned int flags):
     --------
     :py:obj:`~.cuStreamWriteValue32`, :py:obj:`~.cuStreamWaitValue32`, :py:obj:`~.cuStreamWaitValue64`, :py:obj:`~.cuStreamBatchMemOp`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuEventRecord`
     """
-    cdef ccuda.cuuint64_t cvalue
+    cdef cydriver.cuuint64_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint64_t><void_ptr>0
-    elif isinstance(value, (cuuint64_t)):
+        cyvalue = <cydriver.cuuint64_t><void_ptr>0
+    elif isinstance(value, (cuuint64_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint64_t(value))
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWriteValue64(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWriteValue64(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuStreamBatchMemOp' in found_functions}}
 
 @cython.embedsignature(True)
-def cuStreamBatchMemOp(stream, unsigned int count, paramArray : Optional[List[CUstreamBatchMemOpParams]], unsigned int flags):
+def cuStreamBatchMemOp(stream, unsigned int count, paramArray : Optional[Tuple[CUstreamBatchMemOpParams] | List[CUstreamBatchMemOpParams]], unsigned int flags):
     """ Batch operations to synchronize the stream via memory operations.
 
     This is a batch version of :py:obj:`~.cuStreamWaitValue32()` and
@@ -25290,31 +25743,28 @@ def cuStreamBatchMemOp(stream, unsigned int count, paramArray : Optional[List[CU
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
     paramArray = [] if paramArray is None else paramArray
-    if not all(isinstance(_x, (CUstreamBatchMemOpParams)) for _x in paramArray):
-        raise TypeError("Argument 'paramArray' is not instance of type (expected List[ccuda.CUstreamBatchMemOpParams]")
-
-    cdef ccuda.CUstream cstream
+    if not all(isinstance(_x, (CUstreamBatchMemOpParams,)) for _x in paramArray):
+        raise TypeError("Argument 'paramArray' is not instance of type (expected Tuple[cydriver.CUstreamBatchMemOpParams,] or List[cydriver.CUstreamBatchMemOpParams,]")
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
+        cystream = <cydriver.CUstream><void_ptr>pstream
     if count > len(paramArray): raise RuntimeError("List is too small: " + str(len(paramArray)) + " < " + str(count))
-    cdef ccuda.CUstreamBatchMemOpParams* cparamArray = NULL
+    cdef cydriver.CUstreamBatchMemOpParams* cyparamArray = NULL
     if len(paramArray) > 0:
-        cparamArray = <ccuda.CUstreamBatchMemOpParams*> calloc(len(paramArray), sizeof(ccuda.CUstreamBatchMemOpParams))
-        if cparamArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramArray)) + 'x' + str(sizeof(ccuda.CUstreamBatchMemOpParams)))
+        cyparamArray = <cydriver.CUstreamBatchMemOpParams*> calloc(len(paramArray), sizeof(cydriver.CUstreamBatchMemOpParams))
+        if cyparamArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramArray)) + 'x' + str(sizeof(cydriver.CUstreamBatchMemOpParams)))
         for idx in range(len(paramArray)):
-            memcpy(&cparamArray[idx], (<CUstreamBatchMemOpParams>paramArray[idx])._ptr, sizeof(ccuda.CUstreamBatchMemOpParams))
-
-    err = ccuda.cuStreamBatchMemOp(cstream, count, (<CUstreamBatchMemOpParams>paramArray[0])._ptr if len(paramArray) == 1 else cparamArray, flags)
-    if cparamArray is not NULL:
-        free(cparamArray)
+            string.memcpy(&cyparamArray[idx], (<CUstreamBatchMemOpParams>paramArray[idx])._ptr, sizeof(cydriver.CUstreamBatchMemOpParams))
+    err = cydriver.cuStreamBatchMemOp(cystream, count, (<CUstreamBatchMemOpParams>paramArray[0])._ptr if len(paramArray) == 1 else cyparamArray, flags)
+    if cyparamArray is not NULL:
+        free(cyparamArray)
     return (CUresult(err),)
 {{endif}}
 
@@ -25363,37 +25813,34 @@ def cuStreamWaitValue32_v2(stream, addr, value, unsigned int flags):
     -----
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
-    cdef ccuda.cuuint32_t cvalue
+    cdef cydriver.cuuint32_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint32_t><void_ptr>0
-    elif isinstance(value, (cuuint32_t)):
+        cyvalue = <cydriver.cuuint32_t><void_ptr>0
+    elif isinstance(value, (cuuint32_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint32_t(value))
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWaitValue32_v2(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWaitValue32_v2(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25440,37 +25887,34 @@ def cuStreamWaitValue64_v2(stream, addr, value, unsigned int flags):
     -----
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
-    cdef ccuda.cuuint64_t cvalue
+    cdef cydriver.cuuint64_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint64_t><void_ptr>0
-    elif isinstance(value, (cuuint64_t)):
+        cyvalue = <cydriver.cuuint64_t><void_ptr>0
+    elif isinstance(value, (cuuint64_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint64_t(value))
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWaitValue64_v2(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWaitValue64_v2(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25507,37 +25951,34 @@ def cuStreamWriteValue32_v2(stream, addr, value, unsigned int flags):
     --------
     :py:obj:`~.cuStreamWriteValue64_v2`, :py:obj:`~.cuStreamWaitValue32_v2`, :py:obj:`~.cuStreamWaitValue64_v2`, :py:obj:`~.cuStreamBatchMemOp_v2`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuEventRecord`
     """
-    cdef ccuda.cuuint32_t cvalue
+    cdef cydriver.cuuint32_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint32_t><void_ptr>0
-    elif isinstance(value, (cuuint32_t)):
+        cyvalue = <cydriver.cuuint32_t><void_ptr>0
+    elif isinstance(value, (cuuint32_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint32_t(value))
-        cvalue = <ccuda.cuuint32_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint32_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWriteValue32_v2(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWriteValue32_v2(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -25576,44 +26017,41 @@ def cuStreamWriteValue64_v2(stream, addr, value, unsigned int flags):
     --------
     :py:obj:`~.cuStreamWriteValue32_v2`, :py:obj:`~.cuStreamWaitValue32_v2`, :py:obj:`~.cuStreamWaitValue64_v2`, :py:obj:`~.cuStreamBatchMemOp_v2`, :py:obj:`~.cuMemHostRegister`, :py:obj:`~.cuEventRecord`
     """
-    cdef ccuda.cuuint64_t cvalue
+    cdef cydriver.cuuint64_t cyvalue
     if value is None:
-        cvalue = <ccuda.cuuint64_t><void_ptr>0
-    elif isinstance(value, (cuuint64_t)):
+        cyvalue = <cydriver.cuuint64_t><void_ptr>0
+    elif isinstance(value, (cuuint64_t,)):
         pvalue = int(value)
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
     else:
         pvalue = int(cuuint64_t(value))
-        cvalue = <ccuda.cuuint64_t><void_ptr>pvalue
-
-    cdef ccuda.CUdeviceptr caddr
+        cyvalue = <cydriver.cuuint64_t><void_ptr>pvalue
+    cdef cydriver.CUdeviceptr cyaddr
     if addr is None:
-        caddr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(addr, (CUdeviceptr)):
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(addr, (CUdeviceptr,)):
         paddr = int(addr)
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
     else:
         paddr = int(CUdeviceptr(addr))
-        caddr = <ccuda.CUdeviceptr><void_ptr>paddr
-
-    cdef ccuda.CUstream cstream
+        cyaddr = <cydriver.CUdeviceptr><void_ptr>paddr
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
-    err = ccuda.cuStreamWriteValue64_v2(cstream, caddr, cvalue, flags)
+        cystream = <cydriver.CUstream><void_ptr>pstream
+    err = cydriver.cuStreamWriteValue64_v2(cystream, cyaddr, cyvalue, flags)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuStreamBatchMemOp_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cuStreamBatchMemOp_v2(stream, unsigned int count, paramArray : List[CUstreamBatchMemOpParams], unsigned int flags):
+def cuStreamBatchMemOp_v2(stream, unsigned int count, paramArray : Optional[Tuple[CUstreamBatchMemOpParams] | List[CUstreamBatchMemOpParams]], unsigned int flags):
     """ Batch operations to synchronize the stream via memory operations.
 
     This is a batch version of :py:obj:`~.cuStreamWaitValue32_v2()` and
@@ -25657,31 +26095,28 @@ def cuStreamBatchMemOp_v2(stream, unsigned int count, paramArray : List[CUstream
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
     paramArray = [] if paramArray is None else paramArray
-    if not all(isinstance(_x, (CUstreamBatchMemOpParams)) for _x in paramArray):
-        raise TypeError("Argument 'paramArray' is not instance of type (expected List[ccuda.CUstreamBatchMemOpParams]")
-
-    cdef ccuda.CUstream cstream
+    if not all(isinstance(_x, (CUstreamBatchMemOpParams,)) for _x in paramArray):
+        raise TypeError("Argument 'paramArray' is not instance of type (expected Tuple[cydriver.CUstreamBatchMemOpParams,] or List[cydriver.CUstreamBatchMemOpParams,]")
+    cdef cydriver.CUstream cystream
     if stream is None:
-        cstream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(stream, (CUstream)):
+        cystream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(stream, (CUstream,)):
         pstream = int(stream)
-        cstream = <ccuda.CUstream><void_ptr>pstream
+        cystream = <cydriver.CUstream><void_ptr>pstream
     else:
         pstream = int(CUstream(stream))
-        cstream = <ccuda.CUstream><void_ptr>pstream
-
+        cystream = <cydriver.CUstream><void_ptr>pstream
     if count > len(paramArray): raise RuntimeError("List is too small: " + str(len(paramArray)) + " < " + str(count))
-    cdef ccuda.CUstreamBatchMemOpParams* cparamArray = NULL
+    cdef cydriver.CUstreamBatchMemOpParams* cyparamArray = NULL
     if len(paramArray) > 0:
-        cparamArray = <ccuda.CUstreamBatchMemOpParams*> calloc(len(paramArray), sizeof(ccuda.CUstreamBatchMemOpParams))
-        if cparamArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramArray)) + 'x' + str(sizeof(ccuda.CUstreamBatchMemOpParams)))
+        cyparamArray = <cydriver.CUstreamBatchMemOpParams*> calloc(len(paramArray), sizeof(cydriver.CUstreamBatchMemOpParams))
+        if cyparamArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramArray)) + 'x' + str(sizeof(cydriver.CUstreamBatchMemOpParams)))
         for idx in range(len(paramArray)):
-            memcpy(&cparamArray[idx], (<CUstreamBatchMemOpParams>paramArray[idx])._ptr, sizeof(ccuda.CUstreamBatchMemOpParams))
-
-    err = ccuda.cuStreamBatchMemOp_v2(cstream, count, (<CUstreamBatchMemOpParams>paramArray[0])._ptr if len(paramArray) == 1 else cparamArray, flags)
-    if cparamArray is not NULL:
-        free(cparamArray)
+            string.memcpy(&cyparamArray[idx], (<CUstreamBatchMemOpParams>paramArray[idx])._ptr, sizeof(cydriver.CUstreamBatchMemOpParams))
+    err = cydriver.cuStreamBatchMemOp_v2(cystream, count, (<CUstreamBatchMemOpParams>paramArray[0])._ptr if len(paramArray) == 1 else cyparamArray, flags)
+    if cyparamArray is not NULL:
+        free(cyparamArray)
     return (CUresult(err),)
 {{endif}}
 
@@ -25788,19 +26223,18 @@ def cuFuncGetAttribute(attrib not None : CUfunction_attribute, hfunc):
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cudaFuncGetAttributes`, :py:obj:`~.cudaFuncSetAttribute`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef int pi = 0
-    cdef ccuda.CUfunction_attribute cattrib = attrib.value
-    err = ccuda.cuFuncGetAttribute(&pi, cattrib, chfunc)
+    cdef cydriver.CUfunction_attribute cyattrib = attrib.value
+    err = cydriver.cuFuncGetAttribute(&pi, cyattrib, cyhfunc)
     return (CUresult(err), pi)
 {{endif}}
 
@@ -25880,18 +26314,17 @@ def cuFuncSetAttribute(hfunc, attrib not None : CUfunction_attribute, int value)
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cudaFuncGetAttributes`, :py:obj:`~.cudaFuncSetAttribute`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    cdef ccuda.CUfunction_attribute cattrib = attrib.value
-    err = ccuda.cuFuncSetAttribute(chfunc, cattrib, value)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    cdef cydriver.CUfunction_attribute cyattrib = attrib.value
+    err = cydriver.cuFuncSetAttribute(cyhfunc, cyattrib, value)
     return (CUresult(err),)
 {{endif}}
 
@@ -25947,18 +26380,17 @@ def cuFuncSetCacheConfig(hfunc, config not None : CUfunc_cache):
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cudaFuncSetCacheConfig`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    cdef ccuda.CUfunc_cache cconfig = config.value
-    err = ccuda.cuFuncSetCacheConfig(chfunc, cconfig)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    cdef cydriver.CUfunc_cache cyconfig = config.value
+    err = cydriver.cuFuncSetCacheConfig(cyhfunc, cyconfig)
     return (CUresult(err),)
 {{endif}}
 
@@ -26019,18 +26451,17 @@ def cuFuncSetSharedMemConfig(hfunc, config not None : CUsharedconfig):
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuCtxGetSharedMemConfig`, :py:obj:`~.cuCtxSetSharedMemConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cudaFuncSetSharedMemConfig`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    cdef ccuda.CUsharedconfig cconfig = config.value
-    err = ccuda.cuFuncSetSharedMemConfig(chfunc, cconfig)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    cdef cydriver.CUsharedconfig cyconfig = config.value
+    err = cydriver.cuFuncSetSharedMemConfig(cyhfunc, cyconfig)
     return (CUresult(err),)
 {{endif}}
 
@@ -26062,18 +26493,17 @@ def cuFuncGetModule(hfunc):
     hmod : :py:obj:`~.CUmodule`
         Returned module handle
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     cdef CUmodule hmod = CUmodule()
-    err = ccuda.cuFuncGetModule(hmod._ptr, chfunc)
+    err = cydriver.cuFuncGetModule(<cydriver.CUmodule*>hmod._ptr, cyhfunc)
     return (CUresult(err), hmod)
 {{endif}}
 
@@ -26178,28 +26608,26 @@ def cuLaunchKernel(f, unsigned int gridDimX, unsigned int gridDimY, unsigned int
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cudaLaunchKernel`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUfunction cf
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    ckernelParams = utils.HelperKernelParams(kernelParams)
-    err = ccuda.cuLaunchKernel(cf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, chStream, <void**><void_ptr>ckernelParams.ckernelParams, <void**>extra)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    cykernelParams = utils.HelperKernelParams(kernelParams)
+    err = cydriver.cuLaunchKernel(cyf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, cyhStream, <void**><void_ptr>cykernelParams.ckernelParams, <void**>extra)
     return (CUresult(err),)
 {{endif}}
 
@@ -26347,19 +26775,18 @@ def cuLaunchKernelEx(config : Optional[CUlaunchConfig], f, kernelParams, void_pt
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaLaunchKernelEx`
     """
-    cdef ccuda.CUfunction cf
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    cdef ccuda.CUlaunchConfig* cconfig_ptr = config._ptr if config != None else NULL
-    ckernelParams = utils.HelperKernelParams(kernelParams)
-    err = ccuda.cuLaunchKernelEx(cconfig_ptr, cf, <void**><void_ptr>ckernelParams.ckernelParams, <void**>extra)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._ptr if config != None else NULL
+    cykernelParams = utils.HelperKernelParams(kernelParams)
+    err = cydriver.cuLaunchKernelEx(cyconfig_ptr, cyf, <void**><void_ptr>cykernelParams.ckernelParams, <void**>extra)
     return (CUresult(err),)
 {{endif}}
 
@@ -26444,35 +26871,33 @@ def cuLaunchCooperativeKernel(f, unsigned int gridDimX, unsigned int gridDimY, u
     --------
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuLaunchCooperativeKernelMultiDevice`, :py:obj:`~.cudaLaunchCooperativeKernel`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUfunction cf
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    ckernelParams = utils.HelperKernelParams(kernelParams)
-    err = ccuda.cuLaunchCooperativeKernel(cf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, chStream, <void**><void_ptr>ckernelParams.ckernelParams)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    cykernelParams = utils.HelperKernelParams(kernelParams)
+    err = cydriver.cuLaunchCooperativeKernel(cyf, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, cyhStream, <void**><void_ptr>cykernelParams.ckernelParams)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuLaunchCooperativeKernelMultiDevice' in found_functions}}
 
 @cython.embedsignature(True)
-def cuLaunchCooperativeKernelMultiDevice(launchParamsList : Optional[List[CUDA_LAUNCH_PARAMS]], unsigned int numDevices, unsigned int flags):
+def cuLaunchCooperativeKernelMultiDevice(launchParamsList : Optional[Tuple[CUDA_LAUNCH_PARAMS] | List[CUDA_LAUNCH_PARAMS]], unsigned int numDevices, unsigned int flags):
     """ Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute.
 
     [Deprecated]
@@ -26619,21 +27044,19 @@ def cuLaunchCooperativeKernelMultiDevice(launchParamsList : Optional[List[CUDA_L
     :py:obj:`~.cuCtxGetCacheConfig`, :py:obj:`~.cuCtxSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuLaunchCooperativeKernel`, :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice`
     """
     launchParamsList = [] if launchParamsList is None else launchParamsList
-    if not all(isinstance(_x, (CUDA_LAUNCH_PARAMS)) for _x in launchParamsList):
-        raise TypeError("Argument 'launchParamsList' is not instance of type (expected List[ccuda.CUDA_LAUNCH_PARAMS]")
-
-    cdef ccuda.CUDA_LAUNCH_PARAMS* claunchParamsList = NULL
+    if not all(isinstance(_x, (CUDA_LAUNCH_PARAMS,)) for _x in launchParamsList):
+        raise TypeError("Argument 'launchParamsList' is not instance of type (expected Tuple[cydriver.CUDA_LAUNCH_PARAMS,] or List[cydriver.CUDA_LAUNCH_PARAMS,]")
+    cdef cydriver.CUDA_LAUNCH_PARAMS* cylaunchParamsList = NULL
     if len(launchParamsList) > 0:
-        claunchParamsList = <ccuda.CUDA_LAUNCH_PARAMS*> calloc(len(launchParamsList), sizeof(ccuda.CUDA_LAUNCH_PARAMS))
-        if claunchParamsList is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(launchParamsList)) + 'x' + str(sizeof(ccuda.CUDA_LAUNCH_PARAMS)))
+        cylaunchParamsList = <cydriver.CUDA_LAUNCH_PARAMS*> calloc(len(launchParamsList), sizeof(cydriver.CUDA_LAUNCH_PARAMS))
+        if cylaunchParamsList is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(launchParamsList)) + 'x' + str(sizeof(cydriver.CUDA_LAUNCH_PARAMS)))
         for idx in range(len(launchParamsList)):
-            memcpy(&claunchParamsList[idx], (<CUDA_LAUNCH_PARAMS>launchParamsList[idx])._ptr, sizeof(ccuda.CUDA_LAUNCH_PARAMS))
-
+            string.memcpy(&cylaunchParamsList[idx], (<CUDA_LAUNCH_PARAMS>launchParamsList[idx])._ptr, sizeof(cydriver.CUDA_LAUNCH_PARAMS))
     if numDevices > len(launchParamsList): raise RuntimeError("List is too small: " + str(len(launchParamsList)) + " < " + str(numDevices))
-    err = ccuda.cuLaunchCooperativeKernelMultiDevice((<CUDA_LAUNCH_PARAMS>launchParamsList[0])._ptr if len(launchParamsList) == 1 else claunchParamsList, numDevices, flags)
-    if claunchParamsList is not NULL:
-        free(claunchParamsList)
+    err = cydriver.cuLaunchCooperativeKernelMultiDevice((<CUDA_LAUNCH_PARAMS>launchParamsList[0])._ptr if len(launchParamsList) == 1 else cylaunchParamsList, numDevices, flags)
+    if cylaunchParamsList is not NULL:
+        free(cylaunchParamsList)
     return (CUresult(err),)
 {{endif}}
 
@@ -26700,29 +27123,27 @@ def cuLaunchHostFunc(hStream, fn, userData):
     --------
     :py:obj:`~.cuStreamCreate`, :py:obj:`~.cuStreamQuery`, :py:obj:`~.cuStreamSynchronize`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuStreamDestroy`, :py:obj:`~.cuMemAllocManaged`, :py:obj:`~.cuStreamAttachMemAsync`, :py:obj:`~.cuStreamAddCallback`
     """
-    cdef ccuda.CUhostFn cfn
+    cdef cydriver.CUhostFn cyfn
     if fn is None:
-        cfn = <ccuda.CUhostFn><void_ptr>0
-    elif isinstance(fn, (CUhostFn)):
+        cyfn = <cydriver.CUhostFn><void_ptr>0
+    elif isinstance(fn, (CUhostFn,)):
         pfn = int(fn)
-        cfn = <ccuda.CUhostFn><void_ptr>pfn
+        cyfn = <cydriver.CUhostFn><void_ptr>pfn
     else:
         pfn = int(CUhostFn(fn))
-        cfn = <ccuda.CUhostFn><void_ptr>pfn
-
-    cdef ccuda.CUstream chStream
+        cyfn = <cydriver.CUhostFn><void_ptr>pfn
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cuserData = utils.HelperInputVoidPtr(userData)
-    cdef void* cuserData_ptr = <void*><void_ptr>cuserData.cptr
-    err = ccuda.cuLaunchHostFunc(chStream, cfn, cuserData_ptr)
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cyuserData = utils.HelperInputVoidPtr(userData)
+    cdef void* cyuserData_ptr = <void*><void_ptr>cyuserData.cptr
+    err = cydriver.cuLaunchHostFunc(cyhStream, cyfn, cyuserData_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -26757,17 +27178,16 @@ def cuFuncSetBlockShape(hfunc, int x, int y, int z):
     --------
     :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuFuncSetBlockShape(chfunc, x, y, z)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuFuncSetBlockShape(cyhfunc, x, y, z)
     return (CUresult(err),)
 {{endif}}
 
@@ -26799,17 +27219,16 @@ def cuFuncSetSharedSize(hfunc, unsigned int numbytes):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetCacheConfig`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuFuncSetSharedSize(chfunc, numbytes)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuFuncSetSharedSize(cyhfunc, numbytes)
     return (CUresult(err),)
 {{endif}}
 
@@ -26840,17 +27259,16 @@ def cuParamSetSize(hfunc, unsigned int numbytes):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuParamSetSize(chfunc, numbytes)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuParamSetSize(cyhfunc, numbytes)
     return (CUresult(err),)
 {{endif}}
 
@@ -26884,17 +27302,16 @@ def cuParamSeti(hfunc, int offset, unsigned int value):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuParamSeti(chfunc, offset, value)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuParamSeti(cyhfunc, offset, value)
     return (CUresult(err),)
 {{endif}}
 
@@ -26928,17 +27345,16 @@ def cuParamSetf(hfunc, int offset, float value):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuParamSetf(chfunc, offset, value)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuParamSetf(cyhfunc, offset, value)
     return (CUresult(err),)
 {{endif}}
 
@@ -26974,19 +27390,18 @@ def cuParamSetv(hfunc, int offset, ptr, unsigned int numbytes):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction chfunc
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
-    err = ccuda.cuParamSetv(chfunc, offset, cptr_ptr, numbytes)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
+    err = cydriver.cuParamSetv(cyhfunc, offset, cyptr_ptr, numbytes)
     return (CUresult(err),)
 {{endif}}
 
@@ -27028,17 +27443,16 @@ def cuLaunch(f):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunchGrid`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction cf
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    err = ccuda.cuLaunch(cf)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    err = cydriver.cuLaunch(cyf)
     return (CUresult(err),)
 {{endif}}
 
@@ -27084,17 +27498,16 @@ def cuLaunchGrid(f, int grid_width, int grid_height):
     --------
     :py:obj:`~.cuFuncSetBlockShape`, :py:obj:`~.cuFuncSetSharedSize`, :py:obj:`~.cuFuncGetAttribute`, :py:obj:`~.cuParamSetSize`, :py:obj:`~.cuParamSetf`, :py:obj:`~.cuParamSeti`, :py:obj:`~.cuParamSetv`, :py:obj:`~.cuLaunch`, :py:obj:`~.cuLaunchGridAsync`, :py:obj:`~.cuLaunchKernel`
     """
-    cdef ccuda.CUfunction cf
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    err = ccuda.cuLaunchGrid(cf, grid_width, grid_height)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    err = cydriver.cuLaunchGrid(cyf, grid_width, grid_height)
     return (CUresult(err),)
 {{endif}}
 
@@ -27148,27 +27561,25 @@ def cuLaunchGridAsync(f, int grid_width, int grid_height, hStream):
     -----
     In certain cases where cubins are created with no ABI (i.e., using `ptxas` `None` `no`), this function may serialize kernel launches. The CUDA driver retains asynchronous behavior by growing the per-thread stack as needed per launch and not shrinking it afterwards.
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUfunction cf
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUfunction cyf
     if f is None:
-        cf = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(f, (CUfunction)):
+        cyf = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(f, (CUfunction,)):
         pf = int(f)
-        cf = <ccuda.CUfunction><void_ptr>pf
+        cyf = <cydriver.CUfunction><void_ptr>pf
     else:
         pf = int(CUfunction(f))
-        cf = <ccuda.CUfunction><void_ptr>pf
-
-    err = ccuda.cuLaunchGridAsync(cf, grid_width, grid_height, chStream)
+        cyf = <cydriver.CUfunction><void_ptr>pf
+    err = cydriver.cuLaunchGridAsync(cyf, grid_width, grid_height, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -27200,27 +27611,25 @@ def cuParamSetTexRef(hfunc, int texunit, hTexRef):
     CUresult
         :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUfunction chfunc
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUfunction cyhfunc
     if hfunc is None:
-        chfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(hfunc, (CUfunction)):
+        cyhfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(hfunc, (CUfunction,)):
         phfunc = int(hfunc)
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
     else:
         phfunc = int(CUfunction(hfunc))
-        chfunc = <ccuda.CUfunction><void_ptr>phfunc
-
-    err = ccuda.cuParamSetTexRef(chfunc, texunit, chTexRef)
+        cyhfunc = <cydriver.CUfunction><void_ptr>phfunc
+    err = cydriver.cuParamSetTexRef(cyhfunc, texunit, cyhTexRef)
     return (CUresult(err),)
 {{endif}}
 
@@ -27249,14 +27658,14 @@ def cuGraphCreate(unsigned int flags):
     :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`, :py:obj:`~.cuGraphInstantiate`, :py:obj:`~.cuGraphDestroy`, :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphClone`
     """
     cdef CUgraph phGraph = CUgraph()
-    err = ccuda.cuGraphCreate(phGraph._ptr, flags)
+    err = cydriver.cuGraphCreate(<cydriver.CUgraph*>phGraph._ptr, flags)
     return (CUresult(err), phGraph)
 {{endif}}
 
 {{if 'cuGraphAddKernelNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddKernelNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_KERNEL_NODE_PARAMS]):
+def cuGraphAddKernelNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_KERNEL_NODE_PARAMS]):
     """ Creates a kernel execution node and adds it to a graph.
 
     Creates a new kernel execution node and adds it to `hGraph` with
@@ -27345,34 +27754,31 @@ def cuGraphAddKernelNode(hGraph, dependencies : Optional[List[CUgraphNode]], siz
     Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddKernelNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddKernelNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -27409,18 +27815,17 @@ def cuGraphKernelNodeGetParams(hNode):
     --------
     :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphKernelNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_KERNEL_NODE_PARAMS nodeParams = CUDA_KERNEL_NODE_PARAMS()
-    err = ccuda.cuGraphKernelNodeGetParams(chNode, nodeParams._ptr)
+    err = cydriver.cuGraphKernelNodeGetParams(cyhNode, <cydriver.CUDA_KERNEL_NODE_PARAMS*>nodeParams._ptr)
     return (CUresult(err), nodeParams)
 {{endif}}
 
@@ -27448,25 +27853,24 @@ def cuGraphKernelNodeSetParams(hNode, nodeParams : Optional[CUDA_KERNEL_NODE_PAR
     --------
     :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphKernelNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphKernelNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphKernelNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddMemcpyNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddMemcpyNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, copyParams : Optional[CUDA_MEMCPY3D], ctx):
+def cuGraphAddMemcpyNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, copyParams : Optional[CUDA_MEMCPY3D], ctx):
     """ Creates a memcpy node and adds it to a graph.
 
     Creates a new memcpy node and adds it to `hGraph` with
@@ -27513,45 +27917,41 @@ def cuGraphAddMemcpyNode(hGraph, dependencies : Optional[List[CUgraphNode]], siz
     --------
     :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuGraphMemcpyNodeGetParams`, :py:obj:`~.cuGraphMemcpyNodeSetParams`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_MEMCPY3D* ccopyParams_ptr = copyParams._ptr if copyParams != None else NULL
-    err = ccuda.cuGraphAddMemcpyNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, ccopyParams_ptr, cctx)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_MEMCPY3D* cycopyParams_ptr = copyParams._ptr if copyParams != None else NULL
+    err = cydriver.cuGraphAddMemcpyNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cycopyParams_ptr, cyctx)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -27579,18 +27979,17 @@ def cuGraphMemcpyNodeGetParams(hNode):
     --------
     :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphMemcpyNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEMCPY3D nodeParams = CUDA_MEMCPY3D()
-    err = ccuda.cuGraphMemcpyNodeGetParams(chNode, nodeParams._ptr)
+    err = cydriver.cuGraphMemcpyNodeGetParams(cyhNode, <cydriver.CUDA_MEMCPY3D*>nodeParams._ptr)
     return (CUresult(err), nodeParams)
 {{endif}}
 
@@ -27618,25 +28017,24 @@ def cuGraphMemcpyNodeSetParams(hNode, nodeParams : Optional[CUDA_MEMCPY3D]):
     --------
     :py:obj:`~.cuMemcpy3D`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphMemcpyNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_MEMCPY3D* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphMemcpyNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_MEMCPY3D* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphMemcpyNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddMemsetNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddMemsetNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, memsetParams : Optional[CUDA_MEMSET_NODE_PARAMS], ctx):
+def cuGraphAddMemsetNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, memsetParams : Optional[CUDA_MEMSET_NODE_PARAMS], ctx):
     """ Creates a memset node and adds it to a graph.
 
     Creates a new memset node and adds it to `hGraph` with
@@ -27673,45 +28071,41 @@ def cuGraphAddMemsetNode(hGraph, dependencies : Optional[List[CUgraphNode]], siz
     --------
     :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuGraphMemsetNodeGetParams`, :py:obj:`~.cuGraphMemsetNodeSetParams`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemcpyNode`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS* cmemsetParams_ptr = memsetParams._ptr if memsetParams != None else NULL
-    err = ccuda.cuGraphAddMemsetNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cmemsetParams_ptr, cctx)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS* cymemsetParams_ptr = memsetParams._ptr if memsetParams != None else NULL
+    err = cydriver.cuGraphAddMemsetNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cymemsetParams_ptr, cyctx)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -27739,18 +28133,17 @@ def cuGraphMemsetNodeGetParams(hNode):
     --------
     :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuGraphAddMemsetNode`, :py:obj:`~.cuGraphMemsetNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEMSET_NODE_PARAMS nodeParams = CUDA_MEMSET_NODE_PARAMS()
-    err = ccuda.cuGraphMemsetNodeGetParams(chNode, nodeParams._ptr)
+    err = cydriver.cuGraphMemsetNodeGetParams(cyhNode, <cydriver.CUDA_MEMSET_NODE_PARAMS*>nodeParams._ptr)
     return (CUresult(err), nodeParams)
 {{endif}}
 
@@ -27778,25 +28171,24 @@ def cuGraphMemsetNodeSetParams(hNode, nodeParams : Optional[CUDA_MEMSET_NODE_PAR
     --------
     :py:obj:`~.cuMemsetD2D32`, :py:obj:`~.cuGraphAddMemsetNode`, :py:obj:`~.cuGraphMemsetNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphMemsetNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphMemsetNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddHostNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddHostNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_HOST_NODE_PARAMS]):
+def cuGraphAddHostNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_HOST_NODE_PARAMS]):
     """ Creates a host execution node and adds it to a graph.
 
     Creates a new CPU execution node and adds it to `hGraph` with
@@ -27832,34 +28224,31 @@ def cuGraphAddHostNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_
     :py:obj:`~.cuLaunchHostFunc`, :py:obj:`~.cuGraphHostNodeGetParams`, :py:obj:`~.cuGraphHostNodeSetParams`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_HOST_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddHostNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_HOST_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddHostNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -27887,18 +28276,17 @@ def cuGraphHostNodeGetParams(hNode):
     --------
     :py:obj:`~.cuLaunchHostFunc`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphHostNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_HOST_NODE_PARAMS nodeParams = CUDA_HOST_NODE_PARAMS()
-    err = ccuda.cuGraphHostNodeGetParams(chNode, nodeParams._ptr)
+    err = cydriver.cuGraphHostNodeGetParams(cyhNode, <cydriver.CUDA_HOST_NODE_PARAMS*>nodeParams._ptr)
     return (CUresult(err), nodeParams)
 {{endif}}
 
@@ -27926,25 +28314,24 @@ def cuGraphHostNodeSetParams(hNode, nodeParams : Optional[CUDA_HOST_NODE_PARAMS]
     --------
     :py:obj:`~.cuLaunchHostFunc`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphHostNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_HOST_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphHostNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_HOST_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphHostNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddChildGraphNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddChildGraphNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, childGraph):
+def cuGraphAddChildGraphNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, childGraph):
     """ Creates a child graph node and adds it to a graph.
 
     Creates a new node which executes an embedded graph, and adds it to
@@ -27982,44 +28369,40 @@ def cuGraphAddChildGraphNode(hGraph, dependencies : Optional[List[CUgraphNode]],
     --------
     :py:obj:`~.cuGraphChildGraphNodeGetGraph`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`, :py:obj:`~.cuGraphClone`
     """
-    cdef ccuda.CUgraph cchildGraph
+    cdef cydriver.CUgraph cychildGraph
     if childGraph is None:
-        cchildGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(childGraph, (CUgraph)):
+        cychildGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(childGraph, (CUgraph,)):
         pchildGraph = int(childGraph)
-        cchildGraph = <ccuda.CUgraph><void_ptr>pchildGraph
+        cychildGraph = <cydriver.CUgraph><void_ptr>pchildGraph
     else:
         pchildGraph = int(CUgraph(childGraph))
-        cchildGraph = <ccuda.CUgraph><void_ptr>pchildGraph
-
+        cychildGraph = <cydriver.CUgraph><void_ptr>pchildGraph
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuGraphAddChildGraphNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cchildGraph)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuGraphAddChildGraphNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cychildGraph)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28052,25 +28435,24 @@ def cuGraphChildGraphNodeGetGraph(hNode):
     --------
     :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphNodeFindInClone`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUgraph phGraph = CUgraph()
-    err = ccuda.cuGraphChildGraphNodeGetGraph(chNode, phGraph._ptr)
+    err = cydriver.cuGraphChildGraphNodeGetGraph(cyhNode, <cydriver.CUgraph*>phGraph._ptr)
     return (CUresult(err), phGraph)
 {{endif}}
 
 {{if 'cuGraphAddEmptyNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddEmptyNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies):
+def cuGraphAddEmptyNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies):
     """ Creates an empty node and adds it to a graph.
 
     Creates a new node which performs no operation, and adds it to `hGraph`
@@ -28107,40 +28489,37 @@ def cuGraphAddEmptyNode(hGraph, dependencies : Optional[List[CUgraphNode]], size
     :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuGraphAddEmptyNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuGraphAddEmptyNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
 {{if 'cuGraphAddEventRecordNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddEventRecordNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, event):
+def cuGraphAddEventRecordNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, event):
     """ Creates an event record node and adds it to a graph.
 
     Creates a new event record node and adds it to `hGraph` with
@@ -28175,44 +28554,40 @@ def cuGraphAddEventRecordNode(hGraph, dependencies : Optional[List[CUgraphNode]]
     --------
     :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`,
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuGraphAddEventRecordNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cevent)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuGraphAddEventRecordNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cyevent)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28240,18 +28615,17 @@ def cuGraphEventRecordNodeGetEvent(hNode):
     --------
     :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphEventRecordNodeSetEvent`, :py:obj:`~.cuGraphEventWaitNodeGetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUevent event_out = CUevent()
-    err = ccuda.cuGraphEventRecordNodeGetEvent(chNode, event_out._ptr)
+    err = cydriver.cuGraphEventRecordNodeGetEvent(cyhNode, <cydriver.CUevent*>event_out._ptr)
     return (CUresult(err), event_out)
 {{endif}}
 
@@ -28279,34 +28653,32 @@ def cuGraphEventRecordNodeSetEvent(hNode, event):
     --------
     :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphEventRecordNodeGetEvent`, :py:obj:`~.cuGraphEventWaitNodeSetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
-    cdef ccuda.CUgraphNode chNode
+        cyevent = <cydriver.CUevent><void_ptr>pevent
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    err = ccuda.cuGraphEventRecordNodeSetEvent(chNode, cevent)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    err = cydriver.cuGraphEventRecordNodeSetEvent(cyhNode, cyevent)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddEventWaitNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddEventWaitNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, event):
+def cuGraphAddEventWaitNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, event):
     """ Creates an event wait node and adds it to a graph.
 
     Creates a new event wait node and adds it to `hGraph` with
@@ -28343,44 +28715,40 @@ def cuGraphAddEventWaitNode(hGraph, dependencies : Optional[List[CUgraphNode]],
     --------
     :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`,
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuGraphAddEventWaitNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cevent)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuGraphAddEventWaitNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cyevent)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28408,18 +28776,17 @@ def cuGraphEventWaitNodeGetEvent(hNode):
     --------
     :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphEventWaitNodeSetEvent`, :py:obj:`~.cuGraphEventRecordNodeGetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUevent event_out = CUevent()
-    err = ccuda.cuGraphEventWaitNodeGetEvent(chNode, event_out._ptr)
+    err = cydriver.cuGraphEventWaitNodeGetEvent(cyhNode, <cydriver.CUevent*>event_out._ptr)
     return (CUresult(err), event_out)
 {{endif}}
 
@@ -28447,34 +28814,32 @@ def cuGraphEventWaitNodeSetEvent(hNode, event):
     --------
     :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphEventWaitNodeGetEvent`, :py:obj:`~.cuGraphEventRecordNodeSetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
-    cdef ccuda.CUgraphNode chNode
+        cyevent = <cydriver.CUevent><void_ptr>pevent
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    err = ccuda.cuGraphEventWaitNodeSetEvent(chNode, cevent)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    err = cydriver.cuGraphEventWaitNodeSetEvent(cyhNode, cyevent)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresSignalNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddExternalSemaphoresSignalNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_EXT_SEM_SIGNAL_NODE_PARAMS]):
+def cuGraphAddExternalSemaphoresSignalNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_EXT_SEM_SIGNAL_NODE_PARAMS]):
     """ Creates an external semaphore signal node and adds it to a graph.
 
     Creates a new external semaphore signal node and adds it to `hGraph`
@@ -28511,34 +28876,31 @@ def cuGraphAddExternalSemaphoresSignalNode(hGraph, dependencies : Optional[List[
     :py:obj:`~.cuGraphExternalSemaphoresSignalNodeGetParams`, :py:obj:`~.cuGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`,
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddExternalSemaphoresSignalNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddExternalSemaphoresSignalNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28572,18 +28934,17 @@ def cuGraphExternalSemaphoresSignalNodeGetParams(hNode):
     --------
     :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_EXT_SEM_SIGNAL_NODE_PARAMS params_out = CUDA_EXT_SEM_SIGNAL_NODE_PARAMS()
-    err = ccuda.cuGraphExternalSemaphoresSignalNodeGetParams(chNode, params_out._ptr)
+    err = cydriver.cuGraphExternalSemaphoresSignalNodeGetParams(cyhNode, <cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS*>params_out._ptr)
     return (CUresult(err), params_out)
 {{endif}}
 
@@ -28612,25 +28973,24 @@ def cuGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[CU
     --------
     :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExternalSemaphoresSignalNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExternalSemaphoresSignalNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddExternalSemaphoresWaitNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddExternalSemaphoresWaitNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_EXT_SEM_WAIT_NODE_PARAMS]):
+def cuGraphAddExternalSemaphoresWaitNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_EXT_SEM_WAIT_NODE_PARAMS]):
     """ Creates an external semaphore wait node and adds it to a graph.
 
     Creates a new external semaphore wait node and adds it to `hGraph` with
@@ -28667,34 +29027,31 @@ def cuGraphAddExternalSemaphoresWaitNode(hGraph, dependencies : Optional[List[CU
     :py:obj:`~.cuGraphExternalSemaphoresWaitNodeGetParams`, :py:obj:`~.cuGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`,
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddExternalSemaphoresWaitNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddExternalSemaphoresWaitNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28728,18 +29085,17 @@ def cuGraphExternalSemaphoresWaitNodeGetParams(hNode):
     --------
     :py:obj:`~.cuLaunchKernel`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_EXT_SEM_WAIT_NODE_PARAMS params_out = CUDA_EXT_SEM_WAIT_NODE_PARAMS()
-    err = ccuda.cuGraphExternalSemaphoresWaitNodeGetParams(chNode, params_out._ptr)
+    err = cydriver.cuGraphExternalSemaphoresWaitNodeGetParams(cyhNode, <cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS*>params_out._ptr)
     return (CUresult(err), params_out)
 {{endif}}
 
@@ -28768,25 +29124,24 @@ def cuGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[CUDA
     --------
     :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExternalSemaphoresWaitNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExternalSemaphoresWaitNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddBatchMemOpNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddBatchMemOpNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_BATCH_MEM_OP_NODE_PARAMS]):
+def cuGraphAddBatchMemOpNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_BATCH_MEM_OP_NODE_PARAMS]):
     """ Creates a batch memory operation node and adds it to a graph.
 
     Creates a new batch memory operation node and adds it to `hGraph` with
@@ -28826,34 +29181,31 @@ def cuGraphAddBatchMemOpNode(hGraph, dependencies : Optional[List[CUgraphNode]],
     Warning: Improper use of this API may deadlock the application. Synchronization ordering established through this API is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by this API should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order. For more information, see the Stream Memory Operations section in the programming guide(https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html).
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddBatchMemOpNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddBatchMemOpNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -28886,18 +29238,17 @@ def cuGraphBatchMemOpNodeGetParams(hNode):
     --------
     :py:obj:`~.cuStreamBatchMemOp_v2`, :py:obj:`~.cuGraphAddBatchMemOpNode`, :py:obj:`~.cuGraphBatchMemOpNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_BATCH_MEM_OP_NODE_PARAMS nodeParams_out = CUDA_BATCH_MEM_OP_NODE_PARAMS()
-    err = ccuda.cuGraphBatchMemOpNodeGetParams(chNode, nodeParams_out._ptr)
+    err = cydriver.cuGraphBatchMemOpNodeGetParams(cyhNode, <cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS*>nodeParams_out._ptr)
     return (CUresult(err), nodeParams_out)
 {{endif}}
 
@@ -28928,18 +29279,17 @@ def cuGraphBatchMemOpNodeSetParams(hNode, nodeParams : Optional[CUDA_BATCH_MEM_O
     --------
     :py:obj:`~.cuStreamBatchMemOp_v2`, :py:obj:`~.cuGraphAddBatchMemOpNode`, :py:obj:`~.cuGraphBatchMemOpNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphBatchMemOpNodeSetParams(chNode, cnodeParams_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphBatchMemOpNodeSetParams(cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -28992,35 +29342,33 @@ def cuGraphExecBatchMemOpNodeSetParams(hGraphExec, hNode, nodeParams : Optional[
     --------
     :py:obj:`~.cuStreamBatchMemOp_v2`, :py:obj:`~.cuGraphAddBatchMemOpNode`, :py:obj:`~.cuGraphBatchMemOpNodeGetParams`, :py:obj:`~.cuGraphBatchMemOpNodeSetParams`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExecBatchMemOpNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExecBatchMemOpNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphAddMemAllocNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddMemAllocNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_MEM_ALLOC_NODE_PARAMS]):
+def cuGraphAddMemAllocNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, nodeParams : Optional[CUDA_MEM_ALLOC_NODE_PARAMS]):
     """ Creates an allocation node and adds it to a graph.
 
     Creates a new allocation node and adds it to `hGraph` with
@@ -29096,34 +29444,31 @@ def cuGraphAddMemAllocNode(hGraph, dependencies : Optional[List[CUgraphNode]], s
     :py:obj:`~.cuGraphAddMemFreeNode`, :py:obj:`~.cuGraphMemAllocNodeGetParams`, :py:obj:`~.cuDeviceGraphMemTrim`, :py:obj:`~.cuDeviceGetGraphMemAttribute`, :py:obj:`~.cuDeviceSetGraphMemAttribute`, :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    cdef ccuda.CUDA_MEM_ALLOC_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphAddMemAllocNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cnodeParams_ptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    cdef cydriver.CUDA_MEM_ALLOC_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphAddMemAllocNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cynodeParams_ptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -29154,25 +29499,24 @@ def cuGraphMemAllocNodeGetParams(hNode):
     --------
     :py:obj:`~.cuGraphAddMemAllocNode`, :py:obj:`~.cuGraphMemFreeNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUDA_MEM_ALLOC_NODE_PARAMS params_out = CUDA_MEM_ALLOC_NODE_PARAMS()
-    err = ccuda.cuGraphMemAllocNodeGetParams(chNode, params_out._ptr)
+    err = cydriver.cuGraphMemAllocNodeGetParams(cyhNode, <cydriver.CUDA_MEM_ALLOC_NODE_PARAMS*>params_out._ptr)
     return (CUresult(err), params_out)
 {{endif}}
 
 {{if 'cuGraphAddMemFreeNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddMemFreeNode(hGraph, dependencies : Optional[List[CUgraphNode]], size_t numDependencies, dptr):
+def cuGraphAddMemFreeNode(hGraph, dependencies : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies, dptr):
     """ Creates a memory free node and adds it to a graph.
 
     Creates a new memory free node and adds it to `hGraph` with
@@ -29224,44 +29568,40 @@ def cuGraphAddMemFreeNode(hGraph, dependencies : Optional[List[CUgraphNode]], si
     --------
     :py:obj:`~.cuGraphAddMemAllocNode`, :py:obj:`~.cuGraphMemFreeNodeGetParams`, :py:obj:`~.cuDeviceGraphMemTrim`, :py:obj:`~.cuDeviceGetGraphMemAttribute`, :py:obj:`~.cuDeviceSetGraphMemAttribute`, :py:obj:`~.cuMemAllocAsync`, :py:obj:`~.cuMemFreeAsync`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphDestroyNode`, :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphNode phGraphNode = CUgraphNode()
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccuda.CUgraphNode*> calloc(len(dependencies), sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cydependencies = <cydriver.CUgraphNode*> calloc(len(dependencies), sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = (<CUgraphNode>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cydriver.CUgraphNode>(<CUgraphNode>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccuda.cuGraphAddMemFreeNode(phGraphNode._ptr, chGraph, (<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, cdptr)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cydriver.cuGraphAddMemFreeNode(<cydriver.CUgraphNode*>phGraphNode._ptr, cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, cydptr)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), phGraphNode)
 {{endif}}
 
@@ -29289,18 +29629,17 @@ def cuGraphMemFreeNodeGetParams(hNode):
     --------
     :py:obj:`~.cuGraphAddMemFreeNode`, :py:obj:`~.cuGraphMemAllocNodeGetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     cdef CUdeviceptr dptr_out = CUdeviceptr()
-    err = ccuda.cuGraphMemFreeNodeGetParams(chNode, dptr_out._ptr)
+    err = cydriver.cuGraphMemFreeNodeGetParams(cyhNode, <cydriver.CUdeviceptr*>dptr_out._ptr)
     return (CUresult(err), dptr_out)
 {{endif}}
 
@@ -29328,17 +29667,16 @@ def cuDeviceGraphMemTrim(device):
     --------
     :py:obj:`~.cuGraphAddMemAllocNode`, :py:obj:`~.cuGraphAddMemFreeNode`, :py:obj:`~.cuDeviceSetGraphMemAttribute`, :py:obj:`~.cuDeviceGetGraphMemAttribute`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    err = ccuda.cuDeviceGraphMemTrim(cdevice)
+        cydevice = <cydriver.CUdevice>pdevice
+    err = cydriver.cuDeviceGraphMemTrim(cydevice)
     return (CUresult(err),)
 {{endif}}
 
@@ -29383,21 +29721,20 @@ def cuDeviceGetGraphMemAttribute(device, attr not None : CUgraphMem_attribute):
     --------
     :py:obj:`~.cuDeviceSetGraphMemAttribute`, :py:obj:`~.cuGraphAddMemAllocNode`, :py:obj:`~.cuGraphAddMemFreeNode`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef ccuda.CUgraphMem_attribute cattr = attr.value
-    cdef utils.HelperCUgraphMem_attribute cvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccuda.cuDeviceGetGraphMemAttribute(cdevice, cattr, cvalue_ptr)
-    return (CUresult(err), cvalue.pyObj())
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef cydriver.CUgraphMem_attribute cyattr = attr.value
+    cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cydriver.cuDeviceGetGraphMemAttribute(cydevice, cyattr, cyvalue_ptr)
+    return (CUresult(err), cyvalue.pyObj())
 {{endif}}
 
 {{if 'cuDeviceSetGraphMemAttribute' in found_functions}}
@@ -29434,20 +29771,19 @@ def cuDeviceSetGraphMemAttribute(device, attr not None : CUgraphMem_attribute, v
     --------
     :py:obj:`~.cuDeviceGetGraphMemAttribute`, :py:obj:`~.cuGraphAddMemAllocNode`, :py:obj:`~.cuGraphAddMemFreeNode`
     """
-    cdef ccuda.CUdevice cdevice
+    cdef cydriver.CUdevice cydevice
     if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
         pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
+        cydevice = <cydriver.CUdevice>pdevice
     else:
         pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef ccuda.CUgraphMem_attribute cattr = attr.value
-    cdef utils.HelperCUgraphMem_attribute cvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccuda.cuDeviceSetGraphMemAttribute(cdevice, cattr, cvalue_ptr)
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef cydriver.CUgraphMem_attribute cyattr = attr.value
+    cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cydriver.cuDeviceSetGraphMemAttribute(cydevice, cyattr, cyvalue_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -29481,18 +29817,17 @@ def cuGraphClone(originalGraph):
     --------
     :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphNodeFindInClone`
     """
-    cdef ccuda.CUgraph coriginalGraph
+    cdef cydriver.CUgraph cyoriginalGraph
     if originalGraph is None:
-        coriginalGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(originalGraph, (CUgraph)):
+        cyoriginalGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(originalGraph, (CUgraph,)):
         poriginalGraph = int(originalGraph)
-        coriginalGraph = <ccuda.CUgraph><void_ptr>poriginalGraph
+        cyoriginalGraph = <cydriver.CUgraph><void_ptr>poriginalGraph
     else:
         poriginalGraph = int(CUgraph(originalGraph))
-        coriginalGraph = <ccuda.CUgraph><void_ptr>poriginalGraph
-
+        cyoriginalGraph = <cydriver.CUgraph><void_ptr>poriginalGraph
     cdef CUgraph phGraphClone = CUgraph()
-    err = ccuda.cuGraphClone(phGraphClone._ptr, coriginalGraph)
+    err = cydriver.cuGraphClone(<cydriver.CUgraph*>phGraphClone._ptr, cyoriginalGraph)
     return (CUresult(err), phGraphClone)
 {{endif}}
 
@@ -29529,28 +29864,26 @@ def cuGraphNodeFindInClone(hOriginalNode, hClonedGraph):
     --------
     :py:obj:`~.cuGraphClone`
     """
-    cdef ccuda.CUgraph chClonedGraph
+    cdef cydriver.CUgraph cyhClonedGraph
     if hClonedGraph is None:
-        chClonedGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hClonedGraph, (CUgraph)):
+        cyhClonedGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hClonedGraph, (CUgraph,)):
         phClonedGraph = int(hClonedGraph)
-        chClonedGraph = <ccuda.CUgraph><void_ptr>phClonedGraph
+        cyhClonedGraph = <cydriver.CUgraph><void_ptr>phClonedGraph
     else:
         phClonedGraph = int(CUgraph(hClonedGraph))
-        chClonedGraph = <ccuda.CUgraph><void_ptr>phClonedGraph
-
-    cdef ccuda.CUgraphNode chOriginalNode
+        cyhClonedGraph = <cydriver.CUgraph><void_ptr>phClonedGraph
+    cdef cydriver.CUgraphNode cyhOriginalNode
     if hOriginalNode is None:
-        chOriginalNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hOriginalNode, (CUgraphNode)):
+        cyhOriginalNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hOriginalNode, (CUgraphNode,)):
         phOriginalNode = int(hOriginalNode)
-        chOriginalNode = <ccuda.CUgraphNode><void_ptr>phOriginalNode
+        cyhOriginalNode = <cydriver.CUgraphNode><void_ptr>phOriginalNode
     else:
         phOriginalNode = int(CUgraphNode(hOriginalNode))
-        chOriginalNode = <ccuda.CUgraphNode><void_ptr>phOriginalNode
-
+        cyhOriginalNode = <cydriver.CUgraphNode><void_ptr>phOriginalNode
     cdef CUgraphNode phNode = CUgraphNode()
-    err = ccuda.cuGraphNodeFindInClone(phNode._ptr, chOriginalNode, chClonedGraph)
+    err = cydriver.cuGraphNodeFindInClone(<cydriver.CUgraphNode*>phNode._ptr, cyhOriginalNode, cyhClonedGraph)
     return (CUresult(err), phNode)
 {{endif}}
 
@@ -29578,18 +29911,17 @@ def cuGraphNodeGetType(hNode):
     --------
     :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphChildGraphNodeGetGraph`, :py:obj:`~.cuGraphKernelNodeGetParams`, :py:obj:`~.cuGraphKernelNodeSetParams`, :py:obj:`~.cuGraphHostNodeGetParams`, :py:obj:`~.cuGraphHostNodeSetParams`, :py:obj:`~.cuGraphMemcpyNodeGetParams`, :py:obj:`~.cuGraphMemcpyNodeSetParams`, :py:obj:`~.cuGraphMemsetNodeGetParams`, :py:obj:`~.cuGraphMemsetNodeSetParams`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphNodeType typename
-    err = ccuda.cuGraphNodeGetType(chNode, &typename)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphNodeType typename
+    err = cydriver.cuGraphNodeGetType(cyhNode, &typename)
     return (CUresult(err), CUgraphNodeType(typename))
 {{endif}}
 
@@ -29627,27 +29959,26 @@ def cuGraphGetNodes(hGraph, size_t numNodes = 0):
     :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphNodeGetType`, :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphNodeGetDependentNodes`
     """
     cdef size_t _graph_length = numNodes
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphNode* cnodes = NULL
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphNode* cynodes = NULL
     pynodes = []
     if _graph_length != 0:
-        cnodes = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if cnodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    err = ccuda.cuGraphGetNodes(chGraph, cnodes, &numNodes)
+        cynodes = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cynodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    err = cydriver.cuGraphGetNodes(cyhGraph, cynodes, &numNodes)
     if CUresult(err) == CUresult(0):
-        pynodes = [CUgraphNode(init_value=<void_ptr>cnodes[idx]) for idx in range(_graph_length)]
-    if cnodes is not NULL:
-        free(cnodes)
+        pynodes = [CUgraphNode(init_value=<void_ptr>cynodes[idx]) for idx in range(_graph_length)]
+    if cynodes is not NULL:
+        free(cynodes)
     return (CUresult(err), pynodes, numNodes)
 {{endif}}
 
@@ -29685,27 +30016,26 @@ def cuGraphGetRootNodes(hGraph, size_t numRootNodes = 0):
     :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphNodeGetType`, :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphNodeGetDependentNodes`
     """
     cdef size_t _graph_length = numRootNodes
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphNode* crootNodes = NULL
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphNode* cyrootNodes = NULL
     pyrootNodes = []
     if _graph_length != 0:
-        crootNodes = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if crootNodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    err = ccuda.cuGraphGetRootNodes(chGraph, crootNodes, &numRootNodes)
+        cyrootNodes = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cyrootNodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    err = cydriver.cuGraphGetRootNodes(cyhGraph, cyrootNodes, &numRootNodes)
     if CUresult(err) == CUresult(0):
-        pyrootNodes = [CUgraphNode(init_value=<void_ptr>crootNodes[idx]) for idx in range(_graph_length)]
-    if crootNodes is not NULL:
-        free(crootNodes)
+        pyrootNodes = [CUgraphNode(init_value=<void_ptr>cyrootNodes[idx]) for idx in range(_graph_length)]
+    if cyrootNodes is not NULL:
+        free(cyrootNodes)
     return (CUresult(err), pyrootNodes, numRootNodes)
 {{endif}}
 
@@ -29747,37 +30077,36 @@ def cuGraphGetEdges(hGraph, size_t numEdges = 0):
     :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphAddDependencies`, :py:obj:`~.cuGraphRemoveDependencies`, :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphNodeGetDependentNodes`
     """
     cdef size_t _graph_length = numEdges
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphNode* cfrom_ = NULL
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphNode* cyfrom_ = NULL
     pyfrom_ = []
     if _graph_length != 0:
-        cfrom_ = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    cdef ccuda.CUgraphNode* cto = NULL
+        cyfrom_ = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    cdef cydriver.CUgraphNode* cyto = NULL
     pyto = []
     if _graph_length != 0:
-        cto = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    err = ccuda.cuGraphGetEdges(chGraph, cfrom_, cto, &numEdges)
+        cyto = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    err = cydriver.cuGraphGetEdges(cyhGraph, cyfrom_, cyto, &numEdges)
     if CUresult(err) == CUresult(0):
-        pyfrom_ = [CUgraphNode(init_value=<void_ptr>cfrom_[idx]) for idx in range(_graph_length)]
-    if cfrom_ is not NULL:
-        free(cfrom_)
+        pyfrom_ = [CUgraphNode(init_value=<void_ptr>cyfrom_[idx]) for idx in range(_graph_length)]
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
     if CUresult(err) == CUresult(0):
-        pyto = [CUgraphNode(init_value=<void_ptr>cto[idx]) for idx in range(_graph_length)]
-    if cto is not NULL:
-        free(cto)
+        pyto = [CUgraphNode(init_value=<void_ptr>cyto[idx]) for idx in range(_graph_length)]
+    if cyto is not NULL:
+        free(cyto)
     return (CUresult(err), pyfrom_, pyto, numEdges)
 {{endif}}
 
@@ -29816,27 +30145,26 @@ def cuGraphNodeGetDependencies(hNode, size_t numDependencies = 0):
     :py:obj:`~.cuGraphNodeGetDependentNodes`, :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphAddDependencies`, :py:obj:`~.cuGraphRemoveDependencies`
     """
     cdef size_t _graph_length = numDependencies
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphNode* cdependencies = NULL
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphNode* cydependencies = NULL
     pydependencies = []
     if _graph_length != 0:
-        cdependencies = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    err = ccuda.cuGraphNodeGetDependencies(chNode, cdependencies, &numDependencies)
+        cydependencies = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    err = cydriver.cuGraphNodeGetDependencies(cyhNode, cydependencies, &numDependencies)
     if CUresult(err) == CUresult(0):
-        pydependencies = [CUgraphNode(init_value=<void_ptr>cdependencies[idx]) for idx in range(_graph_length)]
-    if cdependencies is not NULL:
-        free(cdependencies)
+        pydependencies = [CUgraphNode(init_value=<void_ptr>cydependencies[idx]) for idx in range(_graph_length)]
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (CUresult(err), pydependencies, numDependencies)
 {{endif}}
 
@@ -29875,34 +30203,33 @@ def cuGraphNodeGetDependentNodes(hNode, size_t numDependentNodes = 0):
     :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphGetNodes`, :py:obj:`~.cuGraphGetRootNodes`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphAddDependencies`, :py:obj:`~.cuGraphRemoveDependencies`
     """
     cdef size_t _graph_length = numDependentNodes
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphNode* cdependentNodes = NULL
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphNode* cydependentNodes = NULL
     pydependentNodes = []
     if _graph_length != 0:
-        cdependentNodes = <ccuda.CUgraphNode*>calloc(_graph_length, sizeof(ccuda.CUgraphNode))
-        if cdependentNodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccuda.CUgraphNode)))
-    err = ccuda.cuGraphNodeGetDependentNodes(chNode, cdependentNodes, &numDependentNodes)
+        cydependentNodes = <cydriver.CUgraphNode*>calloc(_graph_length, sizeof(cydriver.CUgraphNode))
+        if cydependentNodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cydriver.CUgraphNode)))
+    err = cydriver.cuGraphNodeGetDependentNodes(cyhNode, cydependentNodes, &numDependentNodes)
     if CUresult(err) == CUresult(0):
-        pydependentNodes = [CUgraphNode(init_value=<void_ptr>cdependentNodes[idx]) for idx in range(_graph_length)]
-    if cdependentNodes is not NULL:
-        free(cdependentNodes)
+        pydependentNodes = [CUgraphNode(init_value=<void_ptr>cydependentNodes[idx]) for idx in range(_graph_length)]
+    if cydependentNodes is not NULL:
+        free(cydependentNodes)
     return (CUresult(err), pydependentNodes, numDependentNodes)
 {{endif}}
 
 {{if 'cuGraphAddDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphAddDependencies(hGraph, from_ : Optional[List[CUgraphNode]], to : Optional[List[CUgraphNode]], size_t numDependencies):
+def cuGraphAddDependencies(hGraph, from_ : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], to : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies):
     """ Adds dependency edges to a graph.
 
     The number of dependencies to be added is defined by `numDependencies`
@@ -29933,53 +30260,48 @@ def cuGraphAddDependencies(hGraph, from_ : Optional[List[CUgraphNode]], to : Opt
     :py:obj:`~.cuGraphRemoveDependencies`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphNodeGetDependentNodes`
     """
     to = [] if to is None else to
-    if not all(isinstance(_x, (CUgraphNode)) for _x in to):
-        raise TypeError("Argument 'to' is not instance of type (expected List[ccuda.CUgraphNode]")
-
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in to):
+        raise TypeError("Argument 'to' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
     from_ = [] if from_ is None else from_
-    if not all(isinstance(_x, (CUgraphNode)) for _x in from_):
-        raise TypeError("Argument 'from_' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in from_):
+        raise TypeError("Argument 'from_' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphNode* cfrom_ = NULL
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphNode* cyfrom_ = NULL
     if len(from_) > 0:
-        cfrom_ = <ccuda.CUgraphNode*> calloc(len(from_), sizeof(ccuda.CUgraphNode))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cyfrom_ = <cydriver.CUgraphNode*> calloc(len(from_), sizeof(cydriver.CUgraphNode))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(from_)):
-                cfrom_[idx] = (<CUgraphNode>from_[idx])._ptr[0]
-
-    cdef ccuda.CUgraphNode* cto = NULL
+                cyfrom_[idx] = <cydriver.CUgraphNode>(<CUgraphNode>from_[idx])._ptr[0]
+    cdef cydriver.CUgraphNode* cyto = NULL
     if len(to) > 0:
-        cto = <ccuda.CUgraphNode*> calloc(len(to), sizeof(ccuda.CUgraphNode))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cyto = <cydriver.CUgraphNode*> calloc(len(to), sizeof(cydriver.CUgraphNode))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(to)):
-                cto[idx] = (<CUgraphNode>to[idx])._ptr[0]
-
-    err = ccuda.cuGraphAddDependencies(chGraph, (<CUgraphNode>from_[0])._ptr if len(from_) == 1 else cfrom_, (<CUgraphNode>to[0])._ptr if len(to) == 1 else cto, numDependencies)
-    if cfrom_ is not NULL:
-        free(cfrom_)
-    if cto is not NULL:
-        free(cto)
+                cyto[idx] = <cydriver.CUgraphNode>(<CUgraphNode>to[idx])._ptr[0]
+    err = cydriver.cuGraphAddDependencies(cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>from_[0])._ptr if len(from_) == 1 else cyfrom_, <cydriver.CUgraphNode*>(<CUgraphNode>to[0])._ptr if len(to) == 1 else cyto, numDependencies)
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
+    if cyto is not NULL:
+        free(cyto)
     return (CUresult(err),)
 {{endif}}
 
 {{if 'cuGraphRemoveDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cuGraphRemoveDependencies(hGraph, from_ : Optional[List[CUgraphNode]], to : Optional[List[CUgraphNode]], size_t numDependencies):
+def cuGraphRemoveDependencies(hGraph, from_ : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], to : Optional[Tuple[CUgraphNode] | List[CUgraphNode]], size_t numDependencies):
     """ Removes dependency edges from a graph.
 
     The number of `dependencies` to be removed is defined by
@@ -30014,46 +30336,41 @@ def cuGraphRemoveDependencies(hGraph, from_ : Optional[List[CUgraphNode]], to :
     :py:obj:`~.cuGraphAddDependencies`, :py:obj:`~.cuGraphGetEdges`, :py:obj:`~.cuGraphNodeGetDependencies`, :py:obj:`~.cuGraphNodeGetDependentNodes`
     """
     to = [] if to is None else to
-    if not all(isinstance(_x, (CUgraphNode)) for _x in to):
-        raise TypeError("Argument 'to' is not instance of type (expected List[ccuda.CUgraphNode]")
-
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in to):
+        raise TypeError("Argument 'to' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
     from_ = [] if from_ is None else from_
-    if not all(isinstance(_x, (CUgraphNode)) for _x in from_):
-        raise TypeError("Argument 'from_' is not instance of type (expected List[ccuda.CUgraphNode]")
-
-    cdef ccuda.CUgraph chGraph
+    if not all(isinstance(_x, (CUgraphNode,)) for _x in from_):
+        raise TypeError("Argument 'from_' is not instance of type (expected Tuple[cydriver.CUgraphNode,] or List[cydriver.CUgraphNode,]")
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphNode* cfrom_ = NULL
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphNode* cyfrom_ = NULL
     if len(from_) > 0:
-        cfrom_ = <ccuda.CUgraphNode*> calloc(len(from_), sizeof(ccuda.CUgraphNode))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cyfrom_ = <cydriver.CUgraphNode*> calloc(len(from_), sizeof(cydriver.CUgraphNode))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(from_)):
-                cfrom_[idx] = (<CUgraphNode>from_[idx])._ptr[0]
-
-    cdef ccuda.CUgraphNode* cto = NULL
+                cyfrom_[idx] = <cydriver.CUgraphNode>(<CUgraphNode>from_[idx])._ptr[0]
+    cdef cydriver.CUgraphNode* cyto = NULL
     if len(to) > 0:
-        cto = <ccuda.CUgraphNode*> calloc(len(to), sizeof(ccuda.CUgraphNode))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(ccuda.CUgraphNode)))
+        cyto = <cydriver.CUgraphNode*> calloc(len(to), sizeof(cydriver.CUgraphNode))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(cydriver.CUgraphNode)))
         else:
             for idx in range(len(to)):
-                cto[idx] = (<CUgraphNode>to[idx])._ptr[0]
-
-    err = ccuda.cuGraphRemoveDependencies(chGraph, (<CUgraphNode>from_[0])._ptr if len(from_) == 1 else cfrom_, (<CUgraphNode>to[0])._ptr if len(to) == 1 else cto, numDependencies)
-    if cfrom_ is not NULL:
-        free(cfrom_)
-    if cto is not NULL:
-        free(cto)
+                cyto[idx] = <cydriver.CUgraphNode>(<CUgraphNode>to[idx])._ptr[0]
+    err = cydriver.cuGraphRemoveDependencies(cyhGraph, <cydriver.CUgraphNode*>(<CUgraphNode>from_[0])._ptr if len(from_) == 1 else cyfrom_, <cydriver.CUgraphNode*>(<CUgraphNode>to[0])._ptr if len(to) == 1 else cyto, numDependencies)
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
+    if cyto is not NULL:
+        free(cyto)
     return (CUresult(err),)
 {{endif}}
 
@@ -30083,17 +30400,16 @@ def cuGraphDestroyNode(hNode):
     --------
     :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphAddEmptyNode`, :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphAddMemsetNode`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    err = ccuda.cuGraphDestroyNode(chNode)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    err = cydriver.cuGraphDestroyNode(cyhNode)
     return (CUresult(err),)
 {{endif}}
 
@@ -30137,19 +30453,18 @@ def cuGraphInstantiate(hGraph, char* logBuffer, size_t bufferSize):
     --------
     :py:obj:`~.cuGraphInstantiateWithFlags`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphUpload`, :py:obj:`~.cuGraphLaunch`, :py:obj:`~.cuGraphExecDestroy`
     """
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphExec phGraphExec = CUgraphExec()
     cdef CUgraphNode phErrorNode = CUgraphNode()
-    err = ccuda.cuGraphInstantiate(phGraphExec._ptr, chGraph, phErrorNode._ptr, logBuffer, bufferSize)
+    err = cydriver.cuGraphInstantiate(<cydriver.CUgraphExec*>phGraphExec._ptr, cyhGraph, <cydriver.CUgraphNode*>phErrorNode._ptr, logBuffer, bufferSize)
     return (CUresult(err), phGraphExec, phErrorNode)
 {{endif}}
 
@@ -30203,18 +30518,17 @@ def cuGraphInstantiateWithFlags(hGraph, unsigned long long flags):
     --------
     :py:obj:`~.cuGraphInstantiate`, :py:obj:`~.cuGraphCreate`, :py:obj:`~.cuGraphUpload`, :py:obj:`~.cuGraphLaunch`, :py:obj:`~.cuGraphExecDestroy`
     """
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     cdef CUgraphExec phGraphExec = CUgraphExec()
-    err = ccuda.cuGraphInstantiateWithFlags(phGraphExec._ptr, chGraph, flags)
+    err = cydriver.cuGraphInstantiateWithFlags(<cydriver.CUgraphExec*>phGraphExec._ptr, cyhGraph, flags)
     return (CUresult(err), phGraphExec)
 {{endif}}
 
@@ -30260,28 +30574,26 @@ def cuGraphExecKernelNodeSetParams(hGraphExec, hNode, nodeParams : Optional[CUDA
     --------
     :py:obj:`~.cuGraphAddKernelNode`, :py:obj:`~.cuGraphKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_KERNEL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExecKernelNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_KERNEL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExecKernelNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -30330,38 +30642,35 @@ def cuGraphExecMemcpyNodeSetParams(hGraphExec, hNode, copyParams : Optional[CUDA
     --------
     :py:obj:`~.cuGraphAddMemcpyNode`, :py:obj:`~.cuGraphMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    cdef ccuda.CUgraphNode chNode
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_MEMCPY3D* ccopyParams_ptr = copyParams._ptr if copyParams != None else NULL
-    err = ccuda.cuGraphExecMemcpyNodeSetParams(chGraphExec, chNode, ccopyParams_ptr, cctx)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_MEMCPY3D* cycopyParams_ptr = copyParams._ptr if copyParams != None else NULL
+    err = cydriver.cuGraphExecMemcpyNodeSetParams(cyhGraphExec, cyhNode, cycopyParams_ptr, cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -30410,38 +30719,35 @@ def cuGraphExecMemsetNodeSetParams(hGraphExec, hNode, memsetParams : Optional[CU
     --------
     :py:obj:`~.cuGraphAddMemsetNode`, :py:obj:`~.cuGraphMemsetNodeSetParams`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUcontext cctx
+    cdef cydriver.CUcontext cyctx
     if ctx is None:
-        cctx = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(ctx, (CUcontext)):
+        cyctx = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(ctx, (CUcontext,)):
         pctx = int(ctx)
-        cctx = <ccuda.CUcontext><void_ptr>pctx
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
     else:
         pctx = int(CUcontext(ctx))
-        cctx = <ccuda.CUcontext><void_ptr>pctx
-
-    cdef ccuda.CUgraphNode chNode
+        cyctx = <cydriver.CUcontext><void_ptr>pctx
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_MEMSET_NODE_PARAMS* cmemsetParams_ptr = memsetParams._ptr if memsetParams != None else NULL
-    err = ccuda.cuGraphExecMemsetNodeSetParams(chGraphExec, chNode, cmemsetParams_ptr, cctx)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_MEMSET_NODE_PARAMS* cymemsetParams_ptr = memsetParams._ptr if memsetParams != None else NULL
+    err = cydriver.cuGraphExecMemsetNodeSetParams(cyhGraphExec, cyhNode, cymemsetParams_ptr, cyctx)
     return (CUresult(err),)
 {{endif}}
 
@@ -30478,28 +30784,26 @@ def cuGraphExecHostNodeSetParams(hGraphExec, hNode, nodeParams : Optional[CUDA_H
     --------
     :py:obj:`~.cuGraphAddHostNode`, :py:obj:`~.cuGraphHostNodeSetParams`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_HOST_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExecHostNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_HOST_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExecHostNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -30544,37 +30848,34 @@ def cuGraphExecChildGraphNodeSetParams(hGraphExec, hNode, childGraph):
     --------
     :py:obj:`~.cuGraphAddChildGraphNode`, :py:obj:`~.cuGraphChildGraphNodeGetGraph`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraph cchildGraph
+    cdef cydriver.CUgraph cychildGraph
     if childGraph is None:
-        cchildGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(childGraph, (CUgraph)):
+        cychildGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(childGraph, (CUgraph,)):
         pchildGraph = int(childGraph)
-        cchildGraph = <ccuda.CUgraph><void_ptr>pchildGraph
+        cychildGraph = <cydriver.CUgraph><void_ptr>pchildGraph
     else:
         pchildGraph = int(CUgraph(childGraph))
-        cchildGraph = <ccuda.CUgraph><void_ptr>pchildGraph
-
-    cdef ccuda.CUgraphNode chNode
+        cychildGraph = <cydriver.CUgraph><void_ptr>pchildGraph
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphExecChildGraphNodeSetParams(chGraphExec, chNode, cchildGraph)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphExecChildGraphNodeSetParams(cyhGraphExec, cyhNode, cychildGraph)
     return (CUresult(err),)
 {{endif}}
 
@@ -30612,37 +30913,34 @@ def cuGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event):
     --------
     :py:obj:`~.cuGraphAddEventRecordNode`, :py:obj:`~.cuGraphEventRecordNodeGetEvent`, :py:obj:`~.cuGraphEventWaitNodeSetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
-    cdef ccuda.CUgraphNode chNode
+        cyevent = <cydriver.CUevent><void_ptr>pevent
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphExecEventRecordNodeSetEvent(chGraphExec, chNode, cevent)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphExecEventRecordNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
     return (CUresult(err),)
 {{endif}}
 
@@ -30680,37 +30978,34 @@ def cuGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event):
     --------
     :py:obj:`~.cuGraphAddEventWaitNode`, :py:obj:`~.cuGraphEventWaitNodeGetEvent`, :py:obj:`~.cuGraphEventRecordNodeSetEvent`, :py:obj:`~.cuEventRecordWithFlags`, :py:obj:`~.cuStreamWaitEvent`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUevent cevent
+    cdef cydriver.CUevent cyevent
     if event is None:
-        cevent = <ccuda.CUevent><void_ptr>0
-    elif isinstance(event, (CUevent)):
+        cyevent = <cydriver.CUevent><void_ptr>0
+    elif isinstance(event, (CUevent,)):
         pevent = int(event)
-        cevent = <ccuda.CUevent><void_ptr>pevent
+        cyevent = <cydriver.CUevent><void_ptr>pevent
     else:
         pevent = int(CUevent(event))
-        cevent = <ccuda.CUevent><void_ptr>pevent
-
-    cdef ccuda.CUgraphNode chNode
+        cyevent = <cydriver.CUevent><void_ptr>pevent
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphExecEventWaitNodeSetEvent(chGraphExec, chNode, cevent)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphExecEventWaitNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
     return (CUresult(err),)
 {{endif}}
 
@@ -30752,28 +31047,26 @@ def cuGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodePara
     --------
     :py:obj:`~.cuGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExecExternalSemaphoresSignalNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExecExternalSemaphoresSignalNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -30815,28 +31108,26 @@ def cuGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams
     --------
     :py:obj:`~.cuGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cuImportExternalSemaphore`, :py:obj:`~.cuSignalExternalSemaphoresAsync`, :py:obj:`~.cuWaitExternalSemaphoresAsync`, :py:obj:`~.cuGraphExecKernelNodeSetParams`, :py:obj:`~.cuGraphExecMemcpyNodeSetParams`, :py:obj:`~.cuGraphExecMemsetNodeSetParams`, :py:obj:`~.cuGraphExecHostNodeSetParams`, :py:obj:`~.cuGraphExecChildGraphNodeSetParams`, :py:obj:`~.cuGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cuGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cuGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cuGraphExecUpdate`, :py:obj:`~.cuGraphInstantiate`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    cdef ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccuda.cuGraphExecExternalSemaphoresWaitNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    cdef cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cydriver.cuGraphExecExternalSemaphoresWaitNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -30882,27 +31173,25 @@ def cuGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled):
     -----
     Currently only kernel, memset and memcpy nodes are supported.
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphNodeSetEnabled(chGraphExec, chNode, isEnabled)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphNodeSetEnabled(cyhGraphExec, cyhNode, isEnabled)
     return (CUresult(err),)
 {{endif}}
 
@@ -30941,28 +31230,26 @@ def cuGraphNodeGetEnabled(hGraphExec, hNode):
     -----
     Currently only kernel, memset and memcpy nodes are supported.
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef unsigned int isEnabled = 0
-    err = ccuda.cuGraphNodeGetEnabled(chGraphExec, chNode, &isEnabled)
+    err = cydriver.cuGraphNodeGetEnabled(cyhGraphExec, cyhNode, &isEnabled)
     return (CUresult(err), isEnabled)
 {{endif}}
 
@@ -30994,27 +31281,25 @@ def cuGraphUpload(hGraphExec, hStream):
     --------
     :py:obj:`~.cuGraphInstantiate`, :py:obj:`~.cuGraphLaunch`, :py:obj:`~.cuGraphExecDestroy`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphUpload(chGraphExec, chStream)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphUpload(cyhGraphExec, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -31051,27 +31336,25 @@ def cuGraphLaunch(hGraphExec, hStream):
     --------
     :py:obj:`~.cuGraphInstantiate`, :py:obj:`~.cuGraphUpload`, :py:obj:`~.cuGraphExecDestroy`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphLaunch(chGraphExec, chStream)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphLaunch(cyhGraphExec, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -31099,17 +31382,16 @@ def cuGraphExecDestroy(hGraphExec):
     --------
     :py:obj:`~.cuGraphInstantiate`, :py:obj:`~.cuGraphUpload`, :py:obj:`~.cuGraphLaunch`
     """
-    cdef ccuda.CUgraphExec chGraphExec
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
-    err = ccuda.cuGraphExecDestroy(chGraphExec)
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
+    err = cydriver.cuGraphExecDestroy(cyhGraphExec)
     return (CUresult(err),)
 {{endif}}
 
@@ -31135,17 +31417,16 @@ def cuGraphDestroy(hGraph):
     --------
     :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    err = ccuda.cuGraphDestroy(chGraph)
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    err = cydriver.cuGraphDestroy(cyhGraph)
     return (CUresult(err),)
 {{endif}}
 
@@ -31276,29 +31557,27 @@ def cuGraphExecUpdate(hGraphExec, hGraph):
     --------
     :py:obj:`~.cuGraphInstantiate`,
     """
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    cdef ccuda.CUgraphExec chGraphExec
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    cdef cydriver.CUgraphExec cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>0
-    elif isinstance(hGraphExec, (CUgraphExec)):
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>0
+    elif isinstance(hGraphExec, (CUgraphExec,)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     else:
         phGraphExec = int(CUgraphExec(hGraphExec))
-        chGraphExec = <ccuda.CUgraphExec><void_ptr>phGraphExec
-
+        cyhGraphExec = <cydriver.CUgraphExec><void_ptr>phGraphExec
     cdef CUgraphNode hErrorNode_out = CUgraphNode()
-    cdef ccuda.CUgraphExecUpdateResult updateResult_out
-    err = ccuda.cuGraphExecUpdate(chGraphExec, chGraph, hErrorNode_out._ptr, &updateResult_out)
+    cdef cydriver.CUgraphExecUpdateResult updateResult_out
+    err = cydriver.cuGraphExecUpdate(cyhGraphExec, cyhGraph, <cydriver.CUgraphNode*>hErrorNode_out._ptr, &updateResult_out)
     return (CUresult(err), hErrorNode_out, CUgraphExecUpdateResult(updateResult_out))
 {{endif}}
 
@@ -31328,27 +31607,25 @@ def cuGraphKernelNodeCopyAttributes(dst, src):
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUgraphNode csrc
+    cdef cydriver.CUgraphNode cysrc
     if src is None:
-        csrc = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(src, (CUgraphNode)):
+        cysrc = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(src, (CUgraphNode,)):
         psrc = int(src)
-        csrc = <ccuda.CUgraphNode><void_ptr>psrc
+        cysrc = <cydriver.CUgraphNode><void_ptr>psrc
     else:
         psrc = int(CUgraphNode(src))
-        csrc = <ccuda.CUgraphNode><void_ptr>psrc
-
-    cdef ccuda.CUgraphNode cdst
+        cysrc = <cydriver.CUgraphNode><void_ptr>psrc
+    cdef cydriver.CUgraphNode cydst
     if dst is None:
-        cdst = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(dst, (CUgraphNode)):
+        cydst = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(dst, (CUgraphNode,)):
         pdst = int(dst)
-        cdst = <ccuda.CUgraphNode><void_ptr>pdst
+        cydst = <cydriver.CUgraphNode><void_ptr>pdst
     else:
         pdst = int(CUgraphNode(dst))
-        cdst = <ccuda.CUgraphNode><void_ptr>pdst
-
-    err = ccuda.cuGraphKernelNodeCopyAttributes(cdst, csrc)
+        cydst = <cydriver.CUgraphNode><void_ptr>pdst
+    err = cydriver.cuGraphKernelNodeCopyAttributes(cydst, cysrc)
     return (CUresult(err),)
 {{endif}}
 
@@ -31379,19 +31656,18 @@ def cuGraphKernelNodeGetAttribute(hNode, attr not None : CUkernelNodeAttrID):
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUkernelNodeAttrID cattr = attr.value
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUkernelNodeAttrID cyattr = attr.value
     cdef CUkernelNodeAttrValue value_out = CUkernelNodeAttrValue()
-    err = ccuda.cuGraphKernelNodeGetAttribute(chNode, cattr, value_out._ptr)
+    err = cydriver.cuGraphKernelNodeGetAttribute(cyhNode, cyattr, <cydriver.CUkernelNodeAttrValue*>value_out._ptr)
     return (CUresult(err), value_out)
 {{endif}}
 
@@ -31422,19 +31698,18 @@ def cuGraphKernelNodeSetAttribute(hNode, attr not None : CUkernelNodeAttrID, val
     --------
     :py:obj:`~.CUaccessPolicyWindow`
     """
-    cdef ccuda.CUgraphNode chNode
+    cdef cydriver.CUgraphNode cyhNode
     if hNode is None:
-        chNode = <ccuda.CUgraphNode><void_ptr>0
-    elif isinstance(hNode, (CUgraphNode)):
+        cyhNode = <cydriver.CUgraphNode><void_ptr>0
+    elif isinstance(hNode, (CUgraphNode,)):
         phNode = int(hNode)
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
     else:
         phNode = int(CUgraphNode(hNode))
-        chNode = <ccuda.CUgraphNode><void_ptr>phNode
-
-    cdef ccuda.CUkernelNodeAttrID cattr = attr.value
-    cdef ccuda.CUkernelNodeAttrValue* cvalue_ptr = value._ptr if value != None else NULL
-    err = ccuda.cuGraphKernelNodeSetAttribute(chNode, cattr, cvalue_ptr)
+        cyhNode = <cydriver.CUgraphNode><void_ptr>phNode
+    cdef cydriver.CUkernelNodeAttrID cyattr = attr.value
+    cdef cydriver.CUkernelNodeAttrValue* cyvalue_ptr = value._ptr if value != None else NULL
+    err = cydriver.cuGraphKernelNodeSetAttribute(cyhNode, cyattr, cyvalue_ptr)
     return (CUresult(err),)
 {{endif}}
 
@@ -31465,17 +31740,16 @@ def cuGraphDebugDotPrint(hGraph, char* path, unsigned int flags):
     CUresult
         :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_OPERATING_SYSTEM`
     """
-    cdef ccuda.CUgraph chGraph
+    cdef cydriver.CUgraph cyhGraph
     if hGraph is None:
-        chGraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(hGraph, (CUgraph)):
+        cyhGraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(hGraph, (CUgraph,)):
         phGraph = int(hGraph)
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
     else:
         phGraph = int(CUgraph(hGraph))
-        chGraph = <ccuda.CUgraph><void_ptr>phGraph
-
-    err = ccuda.cuGraphDebugDotPrint(chGraph, path, flags)
+        cyhGraph = <cydriver.CUgraph><void_ptr>phGraph
+    err = cydriver.cuGraphDebugDotPrint(cyhGraph, path, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -31523,20 +31797,19 @@ def cuUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned int
     --------
     :py:obj:`~.cuUserObjectRetain`, :py:obj:`~.cuUserObjectRelease`, :py:obj:`~.cuGraphRetainUserObject`, :py:obj:`~.cuGraphReleaseUserObject`, :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUhostFn cdestroy
+    cdef cydriver.CUhostFn cydestroy
     if destroy is None:
-        cdestroy = <ccuda.CUhostFn><void_ptr>0
-    elif isinstance(destroy, (CUhostFn)):
+        cydestroy = <cydriver.CUhostFn><void_ptr>0
+    elif isinstance(destroy, (CUhostFn,)):
         pdestroy = int(destroy)
-        cdestroy = <ccuda.CUhostFn><void_ptr>pdestroy
+        cydestroy = <cydriver.CUhostFn><void_ptr>pdestroy
     else:
         pdestroy = int(CUhostFn(destroy))
-        cdestroy = <ccuda.CUhostFn><void_ptr>pdestroy
-
+        cydestroy = <cydriver.CUhostFn><void_ptr>pdestroy
     cdef CUuserObject object_out = CUuserObject()
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
-    err = ccuda.cuUserObjectCreate(object_out._ptr, cptr_ptr, cdestroy, initialRefcount, flags)
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
+    err = cydriver.cuUserObjectCreate(<cydriver.CUuserObject*>object_out._ptr, cyptr_ptr, cydestroy, initialRefcount, flags)
     return (CUresult(err), object_out)
 {{endif}}
 
@@ -31569,17 +31842,16 @@ def cuUserObjectRetain(object, unsigned int count):
     --------
     :py:obj:`~.cuUserObjectCreate`, :py:obj:`~.cuUserObjectRelease`, :py:obj:`~.cuGraphRetainUserObject`, :py:obj:`~.cuGraphReleaseUserObject`, :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUuserObject cobject
+    cdef cydriver.CUuserObject cyobject
     if object is None:
-        cobject = <ccuda.CUuserObject><void_ptr>0
-    elif isinstance(object, (CUuserObject)):
+        cyobject = <cydriver.CUuserObject><void_ptr>0
+    elif isinstance(object, (CUuserObject,)):
         pobject = int(object)
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
     else:
         pobject = int(CUuserObject(object))
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
-
-    err = ccuda.cuUserObjectRetain(cobject, count)
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
+    err = cydriver.cuUserObjectRetain(cyobject, count)
     return (CUresult(err),)
 {{endif}}
 
@@ -31615,17 +31887,16 @@ def cuUserObjectRelease(object, unsigned int count):
     --------
     :py:obj:`~.cuUserObjectCreate`, :py:obj:`~.cuUserObjectRetain`, :py:obj:`~.cuGraphRetainUserObject`, :py:obj:`~.cuGraphReleaseUserObject`, :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUuserObject cobject
+    cdef cydriver.CUuserObject cyobject
     if object is None:
-        cobject = <ccuda.CUuserObject><void_ptr>0
-    elif isinstance(object, (CUuserObject)):
+        cyobject = <cydriver.CUuserObject><void_ptr>0
+    elif isinstance(object, (CUuserObject,)):
         pobject = int(object)
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
     else:
         pobject = int(CUuserObject(object))
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
-
-    err = ccuda.cuUserObjectRelease(cobject, count)
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
+    err = cydriver.cuUserObjectRelease(cyobject, count)
     return (CUresult(err),)
 {{endif}}
 
@@ -31664,27 +31935,25 @@ def cuGraphRetainUserObject(graph, object, unsigned int count, unsigned int flag
     --------
     :py:obj:`~.cuUserObjectCreate`, :py:obj:`~.cuUserObjectRetain`, :py:obj:`~.cuUserObjectRelease`, :py:obj:`~.cuGraphReleaseUserObject`, :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUuserObject cobject
+    cdef cydriver.CUuserObject cyobject
     if object is None:
-        cobject = <ccuda.CUuserObject><void_ptr>0
-    elif isinstance(object, (CUuserObject)):
+        cyobject = <cydriver.CUuserObject><void_ptr>0
+    elif isinstance(object, (CUuserObject,)):
         pobject = int(object)
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
     else:
         pobject = int(CUuserObject(object))
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
-
-    cdef ccuda.CUgraph cgraph
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
+    cdef cydriver.CUgraph cygraph
     if graph is None:
-        cgraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(graph, (CUgraph)):
+        cygraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(graph, (CUgraph,)):
         pgraph = int(graph)
-        cgraph = <ccuda.CUgraph><void_ptr>pgraph
+        cygraph = <cydriver.CUgraph><void_ptr>pgraph
     else:
         pgraph = int(CUgraph(graph))
-        cgraph = <ccuda.CUgraph><void_ptr>pgraph
-
-    err = ccuda.cuGraphRetainUserObject(cgraph, cobject, count, flags)
+        cygraph = <cydriver.CUgraph><void_ptr>pgraph
+    err = cydriver.cuGraphRetainUserObject(cygraph, cyobject, count, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -31718,27 +31987,25 @@ def cuGraphReleaseUserObject(graph, object, unsigned int count):
     --------
     :py:obj:`~.cuUserObjectCreate`, :py:obj:`~.cuUserObjectRetain`, :py:obj:`~.cuUserObjectRelease`, :py:obj:`~.cuGraphRetainUserObject`, :py:obj:`~.cuGraphCreate`
     """
-    cdef ccuda.CUuserObject cobject
+    cdef cydriver.CUuserObject cyobject
     if object is None:
-        cobject = <ccuda.CUuserObject><void_ptr>0
-    elif isinstance(object, (CUuserObject)):
+        cyobject = <cydriver.CUuserObject><void_ptr>0
+    elif isinstance(object, (CUuserObject,)):
         pobject = int(object)
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
     else:
         pobject = int(CUuserObject(object))
-        cobject = <ccuda.CUuserObject><void_ptr>pobject
-
-    cdef ccuda.CUgraph cgraph
+        cyobject = <cydriver.CUuserObject><void_ptr>pobject
+    cdef cydriver.CUgraph cygraph
     if graph is None:
-        cgraph = <ccuda.CUgraph><void_ptr>0
-    elif isinstance(graph, (CUgraph)):
+        cygraph = <cydriver.CUgraph><void_ptr>0
+    elif isinstance(graph, (CUgraph,)):
         pgraph = int(graph)
-        cgraph = <ccuda.CUgraph><void_ptr>pgraph
+        cygraph = <cydriver.CUgraph><void_ptr>pgraph
     else:
         pgraph = int(CUgraph(graph))
-        cgraph = <ccuda.CUgraph><void_ptr>pgraph
-
-    err = ccuda.cuGraphReleaseUserObject(cgraph, cobject, count)
+        cygraph = <cydriver.CUgraph><void_ptr>pgraph
+    err = cydriver.cuGraphReleaseUserObject(cygraph, cyobject, count)
     return (CUresult(err),)
 {{endif}}
 
@@ -31771,18 +32038,17 @@ def cuOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dyna
     --------
     :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessor`
     """
-    cdef ccuda.CUfunction cfunc
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int numBlocks = 0
-    err = ccuda.cuOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cfunc, blockSize, dynamicSMemSize)
+    err = cydriver.cuOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cyfunc, blockSize, dynamicSMemSize)
     return (CUresult(err), numBlocks)
 {{endif}}
 
@@ -31833,18 +32099,17 @@ def cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize, si
     --------
     :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`
     """
-    cdef ccuda.CUfunction cfunc
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int numBlocks = 0
-    err = ccuda.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cfunc, blockSize, dynamicSMemSize, flags)
+    err = cydriver.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cyfunc, blockSize, dynamicSMemSize, flags)
     return (CUresult(err), numBlocks)
 {{endif}}
 
@@ -31904,29 +32169,27 @@ def cuOccupancyMaxPotentialBlockSize(func, blockSizeToDynamicSMemSize, size_t dy
     --------
     :py:obj:`~.cudaOccupancyMaxPotentialBlockSize`
     """
-    cdef ccuda.CUoccupancyB2DSize cblockSizeToDynamicSMemSize
+    cdef cydriver.CUoccupancyB2DSize cyblockSizeToDynamicSMemSize
     if blockSizeToDynamicSMemSize is None:
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>0
-    elif isinstance(blockSizeToDynamicSMemSize, (CUoccupancyB2DSize)):
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>0
+    elif isinstance(blockSizeToDynamicSMemSize, (CUoccupancyB2DSize,)):
         pblockSizeToDynamicSMemSize = int(blockSizeToDynamicSMemSize)
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
     else:
         pblockSizeToDynamicSMemSize = int(CUoccupancyB2DSize(blockSizeToDynamicSMemSize))
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
-
-    cdef ccuda.CUfunction cfunc
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int minGridSize = 0
     cdef int blockSize = 0
-    err = ccuda.cuOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, cfunc, cblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
+    err = cydriver.cuOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, cyfunc, cyblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit)
     return (CUresult(err), minGridSize, blockSize)
 {{endif}}
 
@@ -31985,29 +32248,27 @@ def cuOccupancyMaxPotentialBlockSizeWithFlags(func, blockSizeToDynamicSMemSize,
     --------
     :py:obj:`~.cudaOccupancyMaxPotentialBlockSizeWithFlags`
     """
-    cdef ccuda.CUoccupancyB2DSize cblockSizeToDynamicSMemSize
+    cdef cydriver.CUoccupancyB2DSize cyblockSizeToDynamicSMemSize
     if blockSizeToDynamicSMemSize is None:
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>0
-    elif isinstance(blockSizeToDynamicSMemSize, (CUoccupancyB2DSize)):
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>0
+    elif isinstance(blockSizeToDynamicSMemSize, (CUoccupancyB2DSize,)):
         pblockSizeToDynamicSMemSize = int(blockSizeToDynamicSMemSize)
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
     else:
         pblockSizeToDynamicSMemSize = int(CUoccupancyB2DSize(blockSizeToDynamicSMemSize))
-        cblockSizeToDynamicSMemSize = <ccuda.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
-
-    cdef ccuda.CUfunction cfunc
+        cyblockSizeToDynamicSMemSize = <cydriver.CUoccupancyB2DSize><void_ptr>pblockSizeToDynamicSMemSize
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int minGridSize = 0
     cdef int blockSize = 0
-    err = ccuda.cuOccupancyMaxPotentialBlockSizeWithFlags(&minGridSize, &blockSize, cfunc, cblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
+    err = cydriver.cuOccupancyMaxPotentialBlockSizeWithFlags(&minGridSize, &blockSize, cyfunc, cyblockSizeToDynamicSMemSize, dynamicSMemSize, blockSizeLimit, flags)
     return (CUresult(err), minGridSize, blockSize)
 {{endif}}
 
@@ -32036,18 +32297,17 @@ def cuOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize):
     dynamicSmemSize : int
         Returned maximum dynamic shared memory
     """
-    cdef ccuda.CUfunction cfunc
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef size_t dynamicSmemSize = 0
-    err = ccuda.cuOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cfunc, numBlocks, blockSize)
+    err = cydriver.cuOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cyfunc, numBlocks, blockSize)
     return (CUresult(err), dynamicSmemSize)
 {{endif}}
 
@@ -32087,19 +32347,18 @@ def cuOccupancyMaxPotentialClusterSize(func, config : Optional[CUlaunchConfig]):
     --------
     :py:obj:`~.cudaFuncGetAttributes` :py:obj:`~.cuFuncGetAttributes`
     """
-    cdef ccuda.CUfunction cfunc
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int clusterSize = 0
-    cdef ccuda.CUlaunchConfig* cconfig_ptr = config._ptr if config != None else NULL
-    err = ccuda.cuOccupancyMaxPotentialClusterSize(&clusterSize, cfunc, cconfig_ptr)
+    cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._ptr if config != None else NULL
+    err = cydriver.cuOccupancyMaxPotentialClusterSize(&clusterSize, cyfunc, cyconfig_ptr)
     return (CUresult(err), clusterSize)
 {{endif}}
 
@@ -32139,19 +32398,18 @@ def cuOccupancyMaxActiveClusters(func, config : Optional[CUlaunchConfig]):
     --------
     :py:obj:`~.cudaFuncGetAttributes` :py:obj:`~.cuFuncGetAttributes`
     """
-    cdef ccuda.CUfunction cfunc
+    cdef cydriver.CUfunction cyfunc
     if func is None:
-        cfunc = <ccuda.CUfunction><void_ptr>0
-    elif isinstance(func, (CUfunction)):
+        cyfunc = <cydriver.CUfunction><void_ptr>0
+    elif isinstance(func, (CUfunction,)):
         pfunc = int(func)
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     else:
         pfunc = int(CUfunction(func))
-        cfunc = <ccuda.CUfunction><void_ptr>pfunc
-
+        cyfunc = <cydriver.CUfunction><void_ptr>pfunc
     cdef int numClusters = 0
-    cdef ccuda.CUlaunchConfig* cconfig_ptr = config._ptr if config != None else NULL
-    err = ccuda.cuOccupancyMaxActiveClusters(&numClusters, cfunc, cconfig_ptr)
+    cdef cydriver.CUlaunchConfig* cyconfig_ptr = config._ptr if config != None else NULL
+    err = cydriver.cuOccupancyMaxActiveClusters(&numClusters, cyfunc, cyconfig_ptr)
     return (CUresult(err), numClusters)
 {{endif}}
 
@@ -32187,27 +32445,25 @@ def cuTexRefSetArray(hTexRef, hArray, unsigned int Flags):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToArray`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
-    cdef ccuda.CUtexref chTexRef
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetArray(chTexRef, chArray, Flags)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetArray(cyhTexRef, cyhArray, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -32243,27 +32499,25 @@ def cuTexRefSetMipmappedArray(hTexRef, hMipmappedArray, unsigned int Flags):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUmipmappedArray chMipmappedArray
+    cdef cydriver.CUmipmappedArray cyhMipmappedArray
     if hMipmappedArray is None:
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>0
-    elif isinstance(hMipmappedArray, (CUmipmappedArray)):
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>0
+    elif isinstance(hMipmappedArray, (CUmipmappedArray,)):
         phMipmappedArray = int(hMipmappedArray)
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
     else:
         phMipmappedArray = int(CUmipmappedArray(hMipmappedArray))
-        chMipmappedArray = <ccuda.CUmipmappedArray><void_ptr>phMipmappedArray
-
-    cdef ccuda.CUtexref chTexRef
+        cyhMipmappedArray = <cydriver.CUmipmappedArray><void_ptr>phMipmappedArray
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetMipmappedArray(chTexRef, chMipmappedArray, Flags)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetMipmappedArray(cyhTexRef, cyhMipmappedArray, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -32318,28 +32572,26 @@ def cuTexRefSetAddress(hTexRef, dptr, size_t numbytes):
     --------
     :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTexture`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    cdef ccuda.CUtexref chTexRef
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef size_t ByteOffset = 0
-    err = ccuda.cuTexRefSetAddress(&ByteOffset, chTexRef, cdptr, numbytes)
+    err = cydriver.cuTexRefSetAddress(&ByteOffset, cyhTexRef, cydptr, numbytes)
     return (CUresult(err), ByteOffset)
 {{endif}}
 
@@ -32402,28 +32654,26 @@ def cuTexRefSetAddress2D(hTexRef, desc : Optional[CUDA_ARRAY_DESCRIPTOR], dptr,
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTexture2D`
     """
-    cdef ccuda.CUdeviceptr cdptr
+    cdef cydriver.CUdeviceptr cydptr
     if dptr is None:
-        cdptr = <ccuda.CUdeviceptr><void_ptr>0
-    elif isinstance(dptr, (CUdeviceptr)):
+        cydptr = <cydriver.CUdeviceptr><void_ptr>0
+    elif isinstance(dptr, (CUdeviceptr,)):
         pdptr = int(dptr)
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
     else:
         pdptr = int(CUdeviceptr(dptr))
-        cdptr = <ccuda.CUdeviceptr><void_ptr>pdptr
-
-    cdef ccuda.CUtexref chTexRef
+        cydptr = <cydriver.CUdeviceptr><void_ptr>pdptr
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUDA_ARRAY_DESCRIPTOR* cdesc_ptr = desc._ptr if desc != None else NULL
-    err = ccuda.cuTexRefSetAddress2D(chTexRef, cdesc_ptr, cdptr, Pitch)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUDA_ARRAY_DESCRIPTOR* cydesc_ptr = desc._ptr if desc != None else NULL
+    err = cydriver.cuTexRefSetAddress2D(cyhTexRef, cydesc_ptr, cydptr, Pitch)
     return (CUresult(err),)
 {{endif}}
 
@@ -32459,18 +32709,17 @@ def cuTexRefSetFormat(hTexRef, fmt not None : CUarray_format, int NumPackedCompo
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaCreateChannelDesc`, :py:obj:`~.cudaBindTexture`, :py:obj:`~.cudaBindTexture2D`, :py:obj:`~.cudaBindTextureToArray`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUarray_format cfmt = fmt.value
-    err = ccuda.cuTexRefSetFormat(chTexRef, cfmt, NumPackedComponents)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUarray_format cyfmt = fmt.value
+    err = cydriver.cuTexRefSetFormat(cyhTexRef, cyfmt, NumPackedComponents)
     return (CUresult(err),)
 {{endif}}
 
@@ -32513,18 +32762,17 @@ def cuTexRefSetAddressMode(hTexRef, int dim, am not None : CUaddress_mode):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTexture`, :py:obj:`~.cudaBindTexture2D`, :py:obj:`~.cudaBindTextureToArray`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUaddress_mode cam = am.value
-    err = ccuda.cuTexRefSetAddressMode(chTexRef, dim, cam)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUaddress_mode cyam = am.value
+    err = cydriver.cuTexRefSetAddressMode(cyhTexRef, dim, cyam)
     return (CUresult(err),)
 {{endif}}
 
@@ -32561,18 +32809,17 @@ def cuTexRefSetFilterMode(hTexRef, fm not None : CUfilter_mode):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUfilter_mode cfm = fm.value
-    err = ccuda.cuTexRefSetFilterMode(chTexRef, cfm)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUfilter_mode cyfm = fm.value
+    err = cydriver.cuTexRefSetFilterMode(cyhTexRef, cyfm)
     return (CUresult(err),)
 {{endif}}
 
@@ -32609,18 +32856,17 @@ def cuTexRefSetMipmapFilterMode(hTexRef, fm not None : CUfilter_mode):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUfilter_mode cfm = fm.value
-    err = ccuda.cuTexRefSetMipmapFilterMode(chTexRef, cfm)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUfilter_mode cyfm = fm.value
+    err = cydriver.cuTexRefSetMipmapFilterMode(cyhTexRef, cyfm)
     return (CUresult(err),)
 {{endif}}
 
@@ -32655,17 +32901,16 @@ def cuTexRefSetMipmapLevelBias(hTexRef, float bias):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetMipmapLevelBias(chTexRef, bias)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetMipmapLevelBias(cyhTexRef, bias)
     return (CUresult(err),)
 {{endif}}
 
@@ -32702,17 +32947,16 @@ def cuTexRefSetMipmapLevelClamp(hTexRef, float minMipmapLevelClamp, float maxMip
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetMipmapLevelClamp(chTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetMipmapLevelClamp(cyhTexRef, minMipmapLevelClamp, maxMipmapLevelClamp)
     return (CUresult(err),)
 {{endif}}
 
@@ -32746,17 +32990,16 @@ def cuTexRefSetMaxAnisotropy(hTexRef, unsigned int maxAniso):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTextureToArray`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetMaxAnisotropy(chTexRef, maxAniso)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetMaxAnisotropy(cyhTexRef, maxAniso)
     return (CUresult(err),)
 {{endif}}
 
@@ -32795,17 +33038,16 @@ def cuTexRefSetBorderColor(hTexRef, float pBorderColor):
     --------
     :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetBorderColor`, :py:obj:`~.cudaBindTexture`, :py:obj:`~.cudaBindTexture2D`, :py:obj:`~.cudaBindTextureToArray`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetBorderColor(chTexRef, &pBorderColor)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetBorderColor(cyhTexRef, &pBorderColor)
     return (CUresult(err),)
 {{endif}}
 
@@ -32854,17 +33096,16 @@ def cuTexRefSetFlags(hTexRef, unsigned int Flags):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`, :py:obj:`~.cudaBindTexture`, :py:obj:`~.cudaBindTexture2D`, :py:obj:`~.cudaBindTextureToArray`, :py:obj:`~.cudaBindTextureToMipmappedArray`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefSetFlags(chTexRef, Flags)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefSetFlags(cyhTexRef, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -32896,18 +33137,17 @@ def cuTexRefGetAddress(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUdeviceptr pdptr = CUdeviceptr()
-    err = ccuda.cuTexRefGetAddress(pdptr._ptr, chTexRef)
+    err = cydriver.cuTexRefGetAddress(<cydriver.CUdeviceptr*>pdptr._ptr, cyhTexRef)
     return (CUresult(err), pdptr)
 {{endif}}
 
@@ -32939,18 +33179,17 @@ def cuTexRefGetArray(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUarray phArray = CUarray()
-    err = ccuda.cuTexRefGetArray(phArray._ptr, chTexRef)
+    err = cydriver.cuTexRefGetArray(<cydriver.CUarray*>phArray._ptr, cyhTexRef)
     return (CUresult(err), phArray)
 {{endif}}
 
@@ -32983,18 +33222,17 @@ def cuTexRefGetMipmappedArray(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef CUmipmappedArray phMipmappedArray = CUmipmappedArray()
-    err = ccuda.cuTexRefGetMipmappedArray(phMipmappedArray._ptr, chTexRef)
+    err = cydriver.cuTexRefGetMipmappedArray(<cydriver.CUmipmappedArray*>phMipmappedArray._ptr, cyhTexRef)
     return (CUresult(err), phMipmappedArray)
 {{endif}}
 
@@ -33028,18 +33266,17 @@ def cuTexRefGetAddressMode(hTexRef, int dim):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUaddress_mode pam
-    err = ccuda.cuTexRefGetAddressMode(&pam, chTexRef, dim)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUaddress_mode pam
+    err = cydriver.cuTexRefGetAddressMode(&pam, cyhTexRef, dim)
     return (CUresult(err), CUaddress_mode(pam))
 {{endif}}
 
@@ -33070,18 +33307,17 @@ def cuTexRefGetFilterMode(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUfilter_mode pfm
-    err = ccuda.cuTexRefGetFilterMode(&pfm, chTexRef)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUfilter_mode pfm
+    err = cydriver.cuTexRefGetFilterMode(&pfm, cyhTexRef)
     return (CUresult(err), CUfilter_mode(pfm))
 {{endif}}
 
@@ -33115,19 +33351,18 @@ def cuTexRefGetFormat(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUarray_format pFormat
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUarray_format pFormat
     cdef int pNumChannels = 0
-    err = ccuda.cuTexRefGetFormat(&pFormat, &pNumChannels, chTexRef)
+    err = cydriver.cuTexRefGetFormat(&pFormat, &pNumChannels, cyhTexRef)
     return (CUresult(err), CUarray_format(pFormat), pNumChannels)
 {{endif}}
 
@@ -33158,18 +33393,17 @@ def cuTexRefGetMipmapFilterMode(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    cdef ccuda.CUfilter_mode pfm
-    err = ccuda.cuTexRefGetMipmapFilterMode(&pfm, chTexRef)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    cdef cydriver.CUfilter_mode pfm
+    err = cydriver.cuTexRefGetMipmapFilterMode(&pfm, cyhTexRef)
     return (CUresult(err), CUfilter_mode(pfm))
 {{endif}}
 
@@ -33201,18 +33435,17 @@ def cuTexRefGetMipmapLevelBias(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef float pbias = 0
-    err = ccuda.cuTexRefGetMipmapLevelBias(&pbias, chTexRef)
+    err = cydriver.cuTexRefGetMipmapLevelBias(&pbias, cyhTexRef)
     return (CUresult(err), pbias)
 {{endif}}
 
@@ -33246,19 +33479,18 @@ def cuTexRefGetMipmapLevelClamp(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef float pminMipmapLevelClamp = 0
     cdef float pmaxMipmapLevelClamp = 0
-    err = ccuda.cuTexRefGetMipmapLevelClamp(&pminMipmapLevelClamp, &pmaxMipmapLevelClamp, chTexRef)
+    err = cydriver.cuTexRefGetMipmapLevelClamp(&pminMipmapLevelClamp, &pmaxMipmapLevelClamp, cyhTexRef)
     return (CUresult(err), pminMipmapLevelClamp, pmaxMipmapLevelClamp)
 {{endif}}
 
@@ -33289,18 +33521,17 @@ def cuTexRefGetMaxAnisotropy(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFlags`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef int pmaxAniso = 0
-    err = ccuda.cuTexRefGetMaxAnisotropy(&pmaxAniso, chTexRef)
+    err = cydriver.cuTexRefGetMaxAnisotropy(&pmaxAniso, cyhTexRef)
     return (CUresult(err), pmaxAniso)
 {{endif}}
 
@@ -33334,18 +33565,17 @@ def cuTexRefGetBorderColor(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetBorderColor`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef float pBorderColor = 0
-    err = ccuda.cuTexRefGetBorderColor(&pBorderColor, chTexRef)
+    err = cydriver.cuTexRefGetBorderColor(&pBorderColor, cyhTexRef)
     return (CUresult(err), pBorderColor)
 {{endif}}
 
@@ -33375,18 +33605,17 @@ def cuTexRefGetFlags(hTexRef):
     --------
     :py:obj:`~.cuTexRefSetAddress`, :py:obj:`~.cuTexRefSetAddress2D`, :py:obj:`~.cuTexRefSetAddressMode`, :py:obj:`~.cuTexRefSetArray`, :py:obj:`~.cuTexRefSetFilterMode`, :py:obj:`~.cuTexRefSetFlags`, :py:obj:`~.cuTexRefSetFormat`, :py:obj:`~.cuTexRefGetAddress`, :py:obj:`~.cuTexRefGetAddressMode`, :py:obj:`~.cuTexRefGetArray`, :py:obj:`~.cuTexRefGetFilterMode`, :py:obj:`~.cuTexRefGetFormat`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     cdef unsigned int pFlags = 0
-    err = ccuda.cuTexRefGetFlags(&pFlags, chTexRef)
+    err = cydriver.cuTexRefGetFlags(&pFlags, cyhTexRef)
     return (CUresult(err), pFlags)
 {{endif}}
 
@@ -33417,7 +33646,7 @@ def cuTexRefCreate():
     :py:obj:`~.cuTexRefDestroy`
     """
     cdef CUtexref pTexRef = CUtexref()
-    err = ccuda.cuTexRefCreate(pTexRef._ptr)
+    err = cydriver.cuTexRefCreate(<cydriver.CUtexref*>pTexRef._ptr)
     return (CUresult(err), pTexRef)
 {{endif}}
 
@@ -33445,17 +33674,16 @@ def cuTexRefDestroy(hTexRef):
     --------
     :py:obj:`~.cuTexRefCreate`
     """
-    cdef ccuda.CUtexref chTexRef
+    cdef cydriver.CUtexref cyhTexRef
     if hTexRef is None:
-        chTexRef = <ccuda.CUtexref><void_ptr>0
-    elif isinstance(hTexRef, (CUtexref)):
+        cyhTexRef = <cydriver.CUtexref><void_ptr>0
+    elif isinstance(hTexRef, (CUtexref,)):
         phTexRef = int(hTexRef)
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
     else:
         phTexRef = int(CUtexref(hTexRef))
-        chTexRef = <ccuda.CUtexref><void_ptr>phTexRef
-
-    err = ccuda.cuTexRefDestroy(chTexRef)
+        cyhTexRef = <cydriver.CUtexref><void_ptr>phTexRef
+    err = cydriver.cuTexRefDestroy(cyhTexRef)
     return (CUresult(err),)
 {{endif}}
 
@@ -33492,27 +33720,25 @@ def cuSurfRefSetArray(hSurfRef, hArray, unsigned int Flags):
     --------
     :py:obj:`~.cuModuleGetSurfRef`, :py:obj:`~.cuSurfRefGetArray`, :py:obj:`~.cudaBindSurfaceToArray`
     """
-    cdef ccuda.CUarray chArray
+    cdef cydriver.CUarray cyhArray
     if hArray is None:
-        chArray = <ccuda.CUarray><void_ptr>0
-    elif isinstance(hArray, (CUarray)):
+        cyhArray = <cydriver.CUarray><void_ptr>0
+    elif isinstance(hArray, (CUarray,)):
         phArray = int(hArray)
-        chArray = <ccuda.CUarray><void_ptr>phArray
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
     else:
         phArray = int(CUarray(hArray))
-        chArray = <ccuda.CUarray><void_ptr>phArray
-
-    cdef ccuda.CUsurfref chSurfRef
+        cyhArray = <cydriver.CUarray><void_ptr>phArray
+    cdef cydriver.CUsurfref cyhSurfRef
     if hSurfRef is None:
-        chSurfRef = <ccuda.CUsurfref><void_ptr>0
-    elif isinstance(hSurfRef, (CUsurfref)):
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>0
+    elif isinstance(hSurfRef, (CUsurfref,)):
         phSurfRef = int(hSurfRef)
-        chSurfRef = <ccuda.CUsurfref><void_ptr>phSurfRef
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
     else:
         phSurfRef = int(CUsurfref(hSurfRef))
-        chSurfRef = <ccuda.CUsurfref><void_ptr>phSurfRef
-
-    err = ccuda.cuSurfRefSetArray(chSurfRef, chArray, Flags)
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
+    err = cydriver.cuSurfRefSetArray(cyhSurfRef, cyhArray, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -33544,18 +33770,17 @@ def cuSurfRefGetArray(hSurfRef):
     --------
     :py:obj:`~.cuModuleGetSurfRef`, :py:obj:`~.cuSurfRefSetArray`
     """
-    cdef ccuda.CUsurfref chSurfRef
+    cdef cydriver.CUsurfref cyhSurfRef
     if hSurfRef is None:
-        chSurfRef = <ccuda.CUsurfref><void_ptr>0
-    elif isinstance(hSurfRef, (CUsurfref)):
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>0
+    elif isinstance(hSurfRef, (CUsurfref,)):
         phSurfRef = int(hSurfRef)
-        chSurfRef = <ccuda.CUsurfref><void_ptr>phSurfRef
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
     else:
         phSurfRef = int(CUsurfref(hSurfRef))
-        chSurfRef = <ccuda.CUsurfref><void_ptr>phSurfRef
-
+        cyhSurfRef = <cydriver.CUsurfref><void_ptr>phSurfRef
     cdef CUarray phArray = CUarray()
-    err = ccuda.cuSurfRefGetArray(phArray._ptr, chSurfRef)
+    err = cydriver.cuSurfRefGetArray(<cydriver.CUarray*>phArray._ptr, cyhSurfRef)
     return (CUresult(err), phArray)
 {{endif}}
 
@@ -33788,10 +34013,10 @@ def cuTexObjectCreate(pResDesc : Optional[CUDA_RESOURCE_DESC], pTexDesc : Option
     :py:obj:`~.cuTexObjectDestroy`, :py:obj:`~.cudaCreateTextureObject`
     """
     cdef CUtexObject pTexObject = CUtexObject()
-    cdef ccuda.CUDA_RESOURCE_DESC* cpResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
-    cdef ccuda.CUDA_TEXTURE_DESC* cpTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
-    cdef ccuda.CUDA_RESOURCE_VIEW_DESC* cpResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
-    err = ccuda.cuTexObjectCreate(pTexObject._ptr, cpResDesc_ptr, cpTexDesc_ptr, cpResViewDesc_ptr)
+    cdef cydriver.CUDA_RESOURCE_DESC* cypResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
+    cdef cydriver.CUDA_TEXTURE_DESC* cypTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
+    cdef cydriver.CUDA_RESOURCE_VIEW_DESC* cypResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
+    err = cydriver.cuTexObjectCreate(<cydriver.CUtexObject*>pTexObject._ptr, cypResDesc_ptr, cypTexDesc_ptr, cypResViewDesc_ptr)
     return (CUresult(err), pTexObject)
 {{endif}}
 
@@ -33817,17 +34042,16 @@ def cuTexObjectDestroy(texObject):
     --------
     :py:obj:`~.cuTexObjectCreate`, :py:obj:`~.cudaDestroyTextureObject`
     """
-    cdef ccuda.CUtexObject ctexObject
+    cdef cydriver.CUtexObject cytexObject
     if texObject is None:
-        ctexObject = <ccuda.CUtexObject><void_ptr>0
-    elif isinstance(texObject, (CUtexObject)):
+        cytexObject = <cydriver.CUtexObject><void_ptr>0
+    elif isinstance(texObject, (CUtexObject,)):
         ptexObject = int(texObject)
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     else:
         ptexObject = int(CUtexObject(texObject))
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
-
-    err = ccuda.cuTexObjectDestroy(ctexObject)
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
+    err = cydriver.cuTexObjectDestroy(cytexObject)
     return (CUresult(err),)
 {{endif}}
 
@@ -33856,18 +34080,17 @@ def cuTexObjectGetResourceDesc(texObject):
     --------
     :py:obj:`~.cuTexObjectCreate`, :py:obj:`~.cudaGetTextureObjectResourceDesc`,
     """
-    cdef ccuda.CUtexObject ctexObject
+    cdef cydriver.CUtexObject cytexObject
     if texObject is None:
-        ctexObject = <ccuda.CUtexObject><void_ptr>0
-    elif isinstance(texObject, (CUtexObject)):
+        cytexObject = <cydriver.CUtexObject><void_ptr>0
+    elif isinstance(texObject, (CUtexObject,)):
         ptexObject = int(texObject)
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     else:
         ptexObject = int(CUtexObject(texObject))
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
-
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_RESOURCE_DESC pResDesc = CUDA_RESOURCE_DESC()
-    err = ccuda.cuTexObjectGetResourceDesc(pResDesc._ptr, ctexObject)
+    err = cydriver.cuTexObjectGetResourceDesc(<cydriver.CUDA_RESOURCE_DESC*>pResDesc._ptr, cytexObject)
     return (CUresult(err), pResDesc)
 {{endif}}
 
@@ -33896,18 +34119,17 @@ def cuTexObjectGetTextureDesc(texObject):
     --------
     :py:obj:`~.cuTexObjectCreate`, :py:obj:`~.cudaGetTextureObjectTextureDesc`
     """
-    cdef ccuda.CUtexObject ctexObject
+    cdef cydriver.CUtexObject cytexObject
     if texObject is None:
-        ctexObject = <ccuda.CUtexObject><void_ptr>0
-    elif isinstance(texObject, (CUtexObject)):
+        cytexObject = <cydriver.CUtexObject><void_ptr>0
+    elif isinstance(texObject, (CUtexObject,)):
         ptexObject = int(texObject)
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     else:
         ptexObject = int(CUtexObject(texObject))
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
-
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_TEXTURE_DESC pTexDesc = CUDA_TEXTURE_DESC()
-    err = ccuda.cuTexObjectGetTextureDesc(pTexDesc._ptr, ctexObject)
+    err = cydriver.cuTexObjectGetTextureDesc(<cydriver.CUDA_TEXTURE_DESC*>pTexDesc._ptr, cytexObject)
     return (CUresult(err), pTexDesc)
 {{endif}}
 
@@ -33937,18 +34159,17 @@ def cuTexObjectGetResourceViewDesc(texObject):
     --------
     :py:obj:`~.cuTexObjectCreate`, :py:obj:`~.cudaGetTextureObjectResourceViewDesc`
     """
-    cdef ccuda.CUtexObject ctexObject
+    cdef cydriver.CUtexObject cytexObject
     if texObject is None:
-        ctexObject = <ccuda.CUtexObject><void_ptr>0
-    elif isinstance(texObject, (CUtexObject)):
+        cytexObject = <cydriver.CUtexObject><void_ptr>0
+    elif isinstance(texObject, (CUtexObject,)):
         ptexObject = int(texObject)
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     else:
         ptexObject = int(CUtexObject(texObject))
-        ctexObject = <ccuda.CUtexObject><void_ptr>ptexObject
-
+        cytexObject = <cydriver.CUtexObject><void_ptr>ptexObject
     cdef CUDA_RESOURCE_VIEW_DESC pResViewDesc = CUDA_RESOURCE_VIEW_DESC()
-    err = ccuda.cuTexObjectGetResourceViewDesc(pResViewDesc._ptr, ctexObject)
+    err = cydriver.cuTexObjectGetResourceViewDesc(<cydriver.CUDA_RESOURCE_VIEW_DESC*>pResViewDesc._ptr, cytexObject)
     return (CUresult(err), pResViewDesc)
 {{endif}}
 
@@ -33987,8 +34208,8 @@ def cuSurfObjectCreate(pResDesc : Optional[CUDA_RESOURCE_DESC]):
     :py:obj:`~.cuSurfObjectDestroy`, :py:obj:`~.cudaCreateSurfaceObject`
     """
     cdef CUsurfObject pSurfObject = CUsurfObject()
-    cdef ccuda.CUDA_RESOURCE_DESC* cpResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
-    err = ccuda.cuSurfObjectCreate(pSurfObject._ptr, cpResDesc_ptr)
+    cdef cydriver.CUDA_RESOURCE_DESC* cypResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
+    err = cydriver.cuSurfObjectCreate(<cydriver.CUsurfObject*>pSurfObject._ptr, cypResDesc_ptr)
     return (CUresult(err), pSurfObject)
 {{endif}}
 
@@ -34014,17 +34235,16 @@ def cuSurfObjectDestroy(surfObject):
     --------
     :py:obj:`~.cuSurfObjectCreate`, :py:obj:`~.cudaDestroySurfaceObject`
     """
-    cdef ccuda.CUsurfObject csurfObject
+    cdef cydriver.CUsurfObject cysurfObject
     if surfObject is None:
-        csurfObject = <ccuda.CUsurfObject><void_ptr>0
-    elif isinstance(surfObject, (CUsurfObject)):
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>0
+    elif isinstance(surfObject, (CUsurfObject,)):
         psurfObject = int(surfObject)
-        csurfObject = <ccuda.CUsurfObject><void_ptr>psurfObject
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
     else:
         psurfObject = int(CUsurfObject(surfObject))
-        csurfObject = <ccuda.CUsurfObject><void_ptr>psurfObject
-
-    err = ccuda.cuSurfObjectDestroy(csurfObject)
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
+    err = cydriver.cuSurfObjectDestroy(cysurfObject)
     return (CUresult(err),)
 {{endif}}
 
@@ -34053,18 +34273,17 @@ def cuSurfObjectGetResourceDesc(surfObject):
     --------
     :py:obj:`~.cuSurfObjectCreate`, :py:obj:`~.cudaGetSurfaceObjectResourceDesc`
     """
-    cdef ccuda.CUsurfObject csurfObject
+    cdef cydriver.CUsurfObject cysurfObject
     if surfObject is None:
-        csurfObject = <ccuda.CUsurfObject><void_ptr>0
-    elif isinstance(surfObject, (CUsurfObject)):
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>0
+    elif isinstance(surfObject, (CUsurfObject,)):
         psurfObject = int(surfObject)
-        csurfObject = <ccuda.CUsurfObject><void_ptr>psurfObject
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
     else:
         psurfObject = int(CUsurfObject(surfObject))
-        csurfObject = <ccuda.CUsurfObject><void_ptr>psurfObject
-
+        cysurfObject = <cydriver.CUsurfObject><void_ptr>psurfObject
     cdef CUDA_RESOURCE_DESC pResDesc = CUDA_RESOURCE_DESC()
-    err = ccuda.cuSurfObjectGetResourceDesc(pResDesc._ptr, csurfObject)
+    err = cydriver.cuSurfObjectGetResourceDesc(<cydriver.CUDA_RESOURCE_DESC*>pResDesc._ptr, cysurfObject)
     return (CUresult(err), pResDesc)
 {{endif}}
 
@@ -34100,28 +34319,26 @@ def cuDeviceCanAccessPeer(dev, peerDev):
     --------
     :py:obj:`~.cuCtxEnablePeerAccess`, :py:obj:`~.cuCtxDisablePeerAccess`, :py:obj:`~.cudaDeviceCanAccessPeer`
     """
-    cdef ccuda.CUdevice cpeerDev
+    cdef cydriver.CUdevice cypeerDev
     if peerDev is None:
-        cpeerDev = <ccuda.CUdevice>0
-    elif isinstance(peerDev, (CUdevice)):
+        cypeerDev = <cydriver.CUdevice>0
+    elif isinstance(peerDev, (CUdevice,)):
         ppeerDev = int(peerDev)
-        cpeerDev = <ccuda.CUdevice>ppeerDev
+        cypeerDev = <cydriver.CUdevice>ppeerDev
     else:
         ppeerDev = int(CUdevice(peerDev))
-        cpeerDev = <ccuda.CUdevice>ppeerDev
-
-    cdef ccuda.CUdevice cdev
+        cypeerDev = <cydriver.CUdevice>ppeerDev
+    cdef cydriver.CUdevice cydev
     if dev is None:
-        cdev = <ccuda.CUdevice>0
-    elif isinstance(dev, (CUdevice)):
+        cydev = <cydriver.CUdevice>0
+    elif isinstance(dev, (CUdevice,)):
         pdev = int(dev)
-        cdev = <ccuda.CUdevice>pdev
+        cydev = <cydriver.CUdevice>pdev
     else:
         pdev = int(CUdevice(dev))
-        cdev = <ccuda.CUdevice>pdev
-
+        cydev = <cydriver.CUdevice>pdev
     cdef int canAccessPeer = 0
-    err = ccuda.cuDeviceCanAccessPeer(&canAccessPeer, cdev, cpeerDev)
+    err = cydriver.cuDeviceCanAccessPeer(&canAccessPeer, cydev, cypeerDev)
     return (CUresult(err), canAccessPeer)
 {{endif}}
 
@@ -34182,17 +34399,16 @@ def cuCtxEnablePeerAccess(peerContext, unsigned int Flags):
     --------
     :py:obj:`~.cuDeviceCanAccessPeer`, :py:obj:`~.cuCtxDisablePeerAccess`, :py:obj:`~.cudaDeviceEnablePeerAccess`
     """
-    cdef ccuda.CUcontext cpeerContext
+    cdef cydriver.CUcontext cypeerContext
     if peerContext is None:
-        cpeerContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(peerContext, (CUcontext)):
+        cypeerContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(peerContext, (CUcontext,)):
         ppeerContext = int(peerContext)
-        cpeerContext = <ccuda.CUcontext><void_ptr>ppeerContext
+        cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
     else:
         ppeerContext = int(CUcontext(peerContext))
-        cpeerContext = <ccuda.CUcontext><void_ptr>ppeerContext
-
-    err = ccuda.cuCtxEnablePeerAccess(cpeerContext, Flags)
+        cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
+    err = cydriver.cuCtxEnablePeerAccess(cypeerContext, Flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -34223,17 +34439,16 @@ def cuCtxDisablePeerAccess(peerContext):
     --------
     :py:obj:`~.cuDeviceCanAccessPeer`, :py:obj:`~.cuCtxEnablePeerAccess`, :py:obj:`~.cudaDeviceDisablePeerAccess`
     """
-    cdef ccuda.CUcontext cpeerContext
+    cdef cydriver.CUcontext cypeerContext
     if peerContext is None:
-        cpeerContext = <ccuda.CUcontext><void_ptr>0
-    elif isinstance(peerContext, (CUcontext)):
+        cypeerContext = <cydriver.CUcontext><void_ptr>0
+    elif isinstance(peerContext, (CUcontext,)):
         ppeerContext = int(peerContext)
-        cpeerContext = <ccuda.CUcontext><void_ptr>ppeerContext
+        cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
     else:
         ppeerContext = int(CUcontext(peerContext))
-        cpeerContext = <ccuda.CUcontext><void_ptr>ppeerContext
-
-    err = ccuda.cuCtxDisablePeerAccess(cpeerContext)
+        cypeerContext = <cydriver.CUcontext><void_ptr>ppeerContext
+    err = cydriver.cuCtxDisablePeerAccess(cypeerContext)
     return (CUresult(err),)
 {{endif}}
 
@@ -34286,29 +34501,27 @@ def cuDeviceGetP2PAttribute(attrib not None : CUdevice_P2PAttribute, srcDevice,
     --------
     :py:obj:`~.cuCtxEnablePeerAccess`, :py:obj:`~.cuCtxDisablePeerAccess`, :py:obj:`~.cuDeviceCanAccessPeer`, :py:obj:`~.cudaDeviceGetP2PAttribute`
     """
-    cdef ccuda.CUdevice cdstDevice
+    cdef cydriver.CUdevice cydstDevice
     if dstDevice is None:
-        cdstDevice = <ccuda.CUdevice>0
-    elif isinstance(dstDevice, (CUdevice)):
+        cydstDevice = <cydriver.CUdevice>0
+    elif isinstance(dstDevice, (CUdevice,)):
         pdstDevice = int(dstDevice)
-        cdstDevice = <ccuda.CUdevice>pdstDevice
+        cydstDevice = <cydriver.CUdevice>pdstDevice
     else:
         pdstDevice = int(CUdevice(dstDevice))
-        cdstDevice = <ccuda.CUdevice>pdstDevice
-
-    cdef ccuda.CUdevice csrcDevice
+        cydstDevice = <cydriver.CUdevice>pdstDevice
+    cdef cydriver.CUdevice cysrcDevice
     if srcDevice is None:
-        csrcDevice = <ccuda.CUdevice>0
-    elif isinstance(srcDevice, (CUdevice)):
+        cysrcDevice = <cydriver.CUdevice>0
+    elif isinstance(srcDevice, (CUdevice,)):
         psrcDevice = int(srcDevice)
-        csrcDevice = <ccuda.CUdevice>psrcDevice
+        cysrcDevice = <cydriver.CUdevice>psrcDevice
     else:
         psrcDevice = int(CUdevice(srcDevice))
-        csrcDevice = <ccuda.CUdevice>psrcDevice
-
+        cysrcDevice = <cydriver.CUdevice>psrcDevice
     cdef int value = 0
-    cdef ccuda.CUdevice_P2PAttribute cattrib = attrib.value
-    err = ccuda.cuDeviceGetP2PAttribute(&value, cattrib, csrcDevice, cdstDevice)
+    cdef cydriver.CUdevice_P2PAttribute cyattrib = attrib.value
+    err = cydriver.cuDeviceGetP2PAttribute(&value, cyattrib, cysrcDevice, cydstDevice)
     return (CUresult(err), value)
 {{endif}}
 
@@ -34338,17 +34551,16 @@ def cuGraphicsUnregisterResource(resource):
     --------
     :py:obj:`~.cuGraphicsD3D9RegisterResource`, :py:obj:`~.cuGraphicsD3D10RegisterResource`, :py:obj:`~.cuGraphicsD3D11RegisterResource`, :py:obj:`~.cuGraphicsGLRegisterBuffer`, :py:obj:`~.cuGraphicsGLRegisterImage`, :py:obj:`~.cudaGraphicsUnregisterResource`
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
-    err = ccuda.cuGraphicsUnregisterResource(cresource)
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
+    err = cydriver.cuGraphicsUnregisterResource(cyresource)
     return (CUresult(err),)
 {{endif}}
 
@@ -34394,18 +34606,17 @@ def cuGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, unsig
     --------
     :py:obj:`~.cuGraphicsResourceGetMappedPointer`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUarray pArray = CUarray()
-    err = ccuda.cuGraphicsSubResourceGetMappedArray(pArray._ptr, cresource, arrayIndex, mipLevel)
+    err = cydriver.cuGraphicsSubResourceGetMappedArray(<cydriver.CUarray*>pArray._ptr, cyresource, arrayIndex, mipLevel)
     return (CUresult(err), pArray)
 {{endif}}
 
@@ -34440,18 +34651,17 @@ def cuGraphicsResourceGetMappedMipmappedArray(resource):
     --------
     :py:obj:`~.cuGraphicsResourceGetMappedPointer`, :py:obj:`~.cudaGraphicsResourceGetMappedMipmappedArray`
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUmipmappedArray pMipmappedArray = CUmipmappedArray()
-    err = ccuda.cuGraphicsResourceGetMappedMipmappedArray(pMipmappedArray._ptr, cresource)
+    err = cydriver.cuGraphicsResourceGetMappedMipmappedArray(<cydriver.CUmipmappedArray*>pMipmappedArray._ptr, cyresource)
     return (CUresult(err), pMipmappedArray)
 {{endif}}
 
@@ -34485,19 +34695,18 @@ def cuGraphicsResourceGetMappedPointer(resource):
     pSize : int
         None
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUdeviceptr pDevPtr = CUdeviceptr()
     cdef size_t pSize = 0
-    err = ccuda.cuGraphicsResourceGetMappedPointer(pDevPtr._ptr, &pSize, cresource)
+    err = cydriver.cuGraphicsResourceGetMappedPointer(<cydriver.CUdeviceptr*>pDevPtr._ptr, &pSize, cyresource)
     return (CUresult(err), pDevPtr, pSize)
 {{endif}}
 
@@ -34547,17 +34756,16 @@ def cuGraphicsResourceSetMapFlags(resource, unsigned int flags):
     --------
     :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cudaGraphicsResourceSetMapFlags`
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
-    err = ccuda.cuGraphicsResourceSetMapFlags(cresource, flags)
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
+    err = cydriver.cuGraphicsResourceSetMapFlags(cyresource, flags)
     return (CUresult(err),)
 {{endif}}
 
@@ -34601,28 +34809,26 @@ def cuGraphicsMapResources(unsigned int count, resources, hStream):
     --------
     :py:obj:`~.cuGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cudaGraphicsMapResources`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUgraphicsResource *cresources
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUgraphicsResource *cyresources
     if resources is None:
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>NULL
-    elif isinstance(resources, (CUgraphicsResource)):
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>NULL
+    elif isinstance(resources, (CUgraphicsResource,)):
         presources = resources.getPtr()
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>presources
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>presources
     elif isinstance(resources, (int)):
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>resources
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>resources
     else:
-        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, cuda.CUgraphicsResource'>, found " + str(type(resources)))
-
-    err = ccuda.cuGraphicsMapResources(count, cresources, chStream)
+        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, driver.CUgraphicsResource'>, found " + str(type(resources)))
+    err = cydriver.cuGraphicsMapResources(count, cyresources, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -34664,28 +34870,26 @@ def cuGraphicsUnmapResources(unsigned int count, resources, hStream):
     --------
     :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cudaGraphicsUnmapResources`
     """
-    cdef ccuda.CUstream chStream
+    cdef cydriver.CUstream cyhStream
     if hStream is None:
-        chStream = <ccuda.CUstream><void_ptr>0
-    elif isinstance(hStream, (CUstream)):
+        cyhStream = <cydriver.CUstream><void_ptr>0
+    elif isinstance(hStream, (CUstream,)):
         phStream = int(hStream)
-        chStream = <ccuda.CUstream><void_ptr>phStream
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
     else:
         phStream = int(CUstream(hStream))
-        chStream = <ccuda.CUstream><void_ptr>phStream
-
-    cdef ccuda.CUgraphicsResource *cresources
+        cyhStream = <cydriver.CUstream><void_ptr>phStream
+    cdef cydriver.CUgraphicsResource *cyresources
     if resources is None:
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>NULL
-    elif isinstance(resources, (CUgraphicsResource)):
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>NULL
+    elif isinstance(resources, (CUgraphicsResource,)):
         presources = resources.getPtr()
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>presources
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>presources
     elif isinstance(resources, (int)):
-        cresources = <ccuda.CUgraphicsResource*><void_ptr>resources
+        cyresources = <cydriver.CUgraphicsResource*><void_ptr>resources
     else:
-        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, cuda.CUgraphicsResource'>, found " + str(type(resources)))
-
-    err = ccuda.cuGraphicsUnmapResources(count, cresources, chStream)
+        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, driver.CUgraphicsResource'>, found " + str(type(resources)))
+    err = cydriver.cuGraphicsUnmapResources(count, cyresources, cyhStream)
     return (CUresult(err),)
 {{endif}}
 
@@ -34759,18 +34963,17 @@ def cuGetProcAddress(char* symbol, int cudaVersion, flags):
     --------
     :py:obj:`~.cudaGetDriverEntryPoint`
     """
-    cdef ccuda.cuuint64_t cflags
+    cdef cydriver.cuuint64_t cyflags
     if flags is None:
-        cflags = <ccuda.cuuint64_t><void_ptr>0
-    elif isinstance(flags, (cuuint64_t)):
+        cyflags = <cydriver.cuuint64_t><void_ptr>0
+    elif isinstance(flags, (cuuint64_t,)):
         pflags = int(flags)
-        cflags = <ccuda.cuuint64_t><void_ptr>pflags
+        cyflags = <cydriver.cuuint64_t><void_ptr>pflags
     else:
         pflags = int(cuuint64_t(flags))
-        cflags = <ccuda.cuuint64_t><void_ptr>pflags
-
+        cyflags = <cydriver.cuuint64_t><void_ptr>pflags
     cdef void_ptr pfn = 0
-    err = ccuda.cuGetProcAddress(symbol, <void**>&pfn, cudaVersion, cflags)
+    err = cydriver.cuGetProcAddress(symbol, <void**>&pfn, cudaVersion, cyflags)
     return (CUresult(err), pfn)
 {{endif}}
 
@@ -34793,8 +34996,8 @@ def cuGetExportTable(pExportTableId : Optional[CUuuid]):
         None
     """
     cdef void_ptr ppExportTable = 0
-    cdef ccuda.CUuuid* cpExportTableId_ptr = pExportTableId._ptr if pExportTableId != None else NULL
-    err = ccuda.cuGetExportTable(<const void**>&ppExportTable, cpExportTableId_ptr)
+    cdef cydriver.CUuuid* cypExportTableId_ptr = pExportTableId._ptr if pExportTableId != None else NULL
+    err = cydriver.cuGetExportTable(<const void**>&ppExportTable, cypExportTableId_ptr)
     return (CUresult(err), ppExportTable)
 {{endif}}
 
@@ -34846,8 +35049,8 @@ def cuProfilerInitialize(char* configFile, char* outputFile, outputMode not None
     --------
     :py:obj:`~.cuProfilerStart`, :py:obj:`~.cuProfilerStop`, :py:obj:`~.cudaProfilerInitialize`
     """
-    cdef ccuda.CUoutput_mode coutputMode = outputMode.value
-    err = ccuda.cuProfilerInitialize(configFile, outputFile, coutputMode)
+    cdef cydriver.CUoutput_mode cyoutputMode = outputMode.value
+    err = cydriver.cuProfilerInitialize(configFile, outputFile, cyoutputMode)
     return (CUresult(err),)
 {{endif}}
 
@@ -34874,7 +35077,7 @@ def cuProfilerStart():
     --------
     :py:obj:`~.cuProfilerInitialize`, :py:obj:`~.cuProfilerStop`, :py:obj:`~.cudaProfilerStart`
     """
-    err = ccuda.cuProfilerStart()
+    err = cydriver.cuProfilerStart()
     return (CUresult(err),)
 {{endif}}
 
@@ -34901,342 +35104,94 @@ def cuProfilerStop():
     --------
     :py:obj:`~.cuProfilerInitialize`, :py:obj:`~.cuProfilerStart`, :py:obj:`~.cudaProfilerStop`
     """
-    err = ccuda.cuProfilerStop()
+    err = cydriver.cuProfilerStop()
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuVDPAUGetDevice' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cuVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
-    """ Gets the CUDA device associated with a VDPAU device.
+def cuGraphicsEGLRegisterImage(image, unsigned int flags):
+    """ Registers an EGL image.
 
-    Returns in `*pDevice` the CUDA device associated with a `vdpDevice`, if
-    applicable.
+    Registers the EGLImageKHR specified by `image` for access by CUDA. A
+    handle to the registered object is returned as `pCudaResource`.
+    Additional Mapping/Unmapping is not required for the registered
+    resource and :py:obj:`~.cuGraphicsResourceGetMappedEglFrame` can be
+    directly called on the `pCudaResource`.
+
+    The application will be responsible for synchronizing access to shared
+    objects. The application must ensure that any pending operation which
+    access the objects have completed before passing control to CUDA. This
+    may be accomplished by issuing and waiting for glFinish command on all
+    GLcontexts (for OpenGL and likewise for other APIs). The application
+    will be also responsible for ensuring that any pending operation on the
+    registered CUDA resource has completed prior to executing subsequent
+    commands in other APIs accesing the same memory objects. This can be
+    accomplished by calling cuCtxSynchronize or cuEventSynchronize
+    (preferably).
+
+    The surface's intended usage is specified using `flags`, as follows:
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
+      about how this resource will be used. It is therefore assumed that
+      this resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
+      CUDA will not write to this resource.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
+      that CUDA will not read from this resource and will write over the
+      entire contents of the resource, so none of the data previously
+      stored in the resource will be preserved.
+
+    The EGLImageKHR is an object which can be used to create EGLImage
+    target resource. It is defined as a void pointer. typedef void*
+    EGLImageKHR
 
     Parameters
     ----------
-    vdpDevice : :py:obj:`~.VdpDevice`
-        A VdpDevice handle
-    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
-        VDPAU's VdpGetProcAddress function pointer
+    image : :py:obj:`~.EGLImageKHR`
+        An EGLImageKHR image which can be used to create target resource.
+    flags : unsigned int
+        Map flags
 
     Returns
     -------
     CUresult
-        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`
-    pDevice : :py:obj:`~.CUdevice`
-        Device associated with vdpDevice
+        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
+    pCudaResource : :py:obj:`~.CUgraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaVDPAUGetDevice`
+    :py:obj:`~.cuGraphicsEGLRegisterImage`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cudaGraphicsEGLRegisterImage`
     """
-    cdef ccuda.VdpGetProcAddress *cvdpGetProcAddress
-    if vdpGetProcAddress is None:
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>NULL
-    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress)):
-        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
-    elif isinstance(vdpGetProcAddress, (int)):
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
-    else:
-        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, cuda.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
-
-    cdef ccuda.VdpDevice cvdpDevice
-    if vdpDevice is None:
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>0
-    elif isinstance(vdpDevice, (VdpDevice)):
-        pvdpDevice = int(vdpDevice)
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>pvdpDevice
+    cdef cydriver.EGLImageKHR cyimage
+    if image is None:
+        cyimage = <cydriver.EGLImageKHR><void_ptr>0
+    elif isinstance(image, (EGLImageKHR,)):
+        pimage = int(image)
+        cyimage = <cydriver.EGLImageKHR><void_ptr>pimage
     else:
-        pvdpDevice = int(VdpDevice(vdpDevice))
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>pvdpDevice
-
-    cdef CUdevice pDevice = CUdevice()
-    err = ccuda.cuVDPAUGetDevice(pDevice._ptr, cvdpDevice, cvdpGetProcAddress)
-    return (CUresult(err), pDevice)
+        pimage = int(EGLImageKHR(image))
+        cyimage = <cydriver.EGLImageKHR><void_ptr>pimage
+    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
+    err = cydriver.cuGraphicsEGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource._ptr, cyimage, flags)
+    return (CUresult(err), pCudaResource)
 {{endif}}
 
-{{if True or 'cuVDPAUCtxCreate_v2' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cuVDPAUCtxCreate(unsigned int flags, device, vdpDevice, vdpGetProcAddress):
-    """ Create a CUDA context for interoperability with VDPAU.
+def cuEGLStreamConsumerConnect(stream):
+    """ Connect CUDA to EGLStream as a consumer.
 
-    Creates a new CUDA context, initializes VDPAU interoperability, and
-    associates the CUDA context with the calling thread. It must be called
-    before performing any other VDPAU interoperability operations. It may
-    fail if the needed VDPAU driver facilities are not available. For usage
-    of the `flags` parameter, see :py:obj:`~.cuCtxCreate()`.
-
-    Parameters
-    ----------
-    flags : unsigned int
-        Options for CUDA context creation
-    device : :py:obj:`~.CUdevice`
-        Device on which to create the context
-    vdpDevice : :py:obj:`~.VdpDevice`
-        The VdpDevice to interop with
-    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
-        VDPAU's VdpGetProcAddress function pointer
-
-    Returns
-    -------
-    CUresult
-        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`
-    pCtx : :py:obj:`~.CUcontext`
-        Returned CUDA context
-
-    See Also
-    --------
-    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`
-    """
-    cdef ccuda.VdpGetProcAddress *cvdpGetProcAddress
-    if vdpGetProcAddress is None:
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>NULL
-    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress)):
-        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
-    elif isinstance(vdpGetProcAddress, (int)):
-        cvdpGetProcAddress = <ccuda.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
-    else:
-        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, cuda.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
-
-    cdef ccuda.VdpDevice cvdpDevice
-    if vdpDevice is None:
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>0
-    elif isinstance(vdpDevice, (VdpDevice)):
-        pvdpDevice = int(vdpDevice)
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>pvdpDevice
-    else:
-        pvdpDevice = int(VdpDevice(vdpDevice))
-        cvdpDevice = <ccuda.VdpDevice><void_ptr>pvdpDevice
-
-    cdef ccuda.CUdevice cdevice
-    if device is None:
-        cdevice = <ccuda.CUdevice>0
-    elif isinstance(device, (CUdevice)):
-        pdevice = int(device)
-        cdevice = <ccuda.CUdevice>pdevice
-    else:
-        pdevice = int(CUdevice(device))
-        cdevice = <ccuda.CUdevice>pdevice
-
-    cdef CUcontext pCtx = CUcontext()
-    err = ccuda.cuVDPAUCtxCreate(pCtx._ptr, flags, cdevice, cvdpDevice, cvdpGetProcAddress)
-    return (CUresult(err), pCtx)
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterVideoSurface' in found_functions}}
-
-@cython.embedsignature(True)
-def cuGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
-    """ Registers a VDPAU VdpVideoSurface object.
-
-    Registers the VdpVideoSurface specified by `vdpSurface` for access by
-    CUDA. A handle to the registered object is returned as `pCudaResource`.
-    The surface's intended usage is specified using `flags`, as follows:
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
-      about how this resource will be used. It is therefore assumed that
-      this resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
-      CUDA will not write to this resource.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
-      that CUDA will not read from this resource and will write over the
-      entire contents of the resource, so none of the data previously
-      stored in the resource will be preserved.
-
-    The VdpVideoSurface is presented as an array of subresources that may
-    be accessed using pointers returned by
-    :py:obj:`~.cuGraphicsSubResourceGetMappedArray`. The exact number of
-    valid `arrayIndex` values depends on the VDPAU surface format. The
-    mapping is shown in the table below. `mipLevel` must be 0.
-
-    Parameters
-    ----------
-    vdpSurface : :py:obj:`~.VdpVideoSurface`
-        The VdpVideoSurface to be registered
-    flags : unsigned int
-        Map flags
-
-    Returns
-    -------
-    CUresult
-        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
-    pCudaResource : :py:obj:`~.CUgraphicsResource`
-        Pointer to the returned object handle
-
-    See Also
-    --------
-    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`, :py:obj:`~.cudaGraphicsVDPAURegisterVideoSurface`
-    """
-    cdef ccuda.VdpVideoSurface cvdpSurface
-    if vdpSurface is None:
-        cvdpSurface = <ccuda.VdpVideoSurface><void_ptr>0
-    elif isinstance(vdpSurface, (VdpVideoSurface)):
-        pvdpSurface = int(vdpSurface)
-        cvdpSurface = <ccuda.VdpVideoSurface><void_ptr>pvdpSurface
-    else:
-        pvdpSurface = int(VdpVideoSurface(vdpSurface))
-        cvdpSurface = <ccuda.VdpVideoSurface><void_ptr>pvdpSurface
-
-    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
-    err = ccuda.cuGraphicsVDPAURegisterVideoSurface(pCudaResource._ptr, cvdpSurface, flags)
-    return (CUresult(err), pCudaResource)
-{{endif}}
-
-{{if True or 'cuGraphicsVDPAURegisterOutputSurface' in found_functions}}
-
-@cython.embedsignature(True)
-def cuGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
-    """ Registers a VDPAU VdpOutputSurface object.
-
-    Registers the VdpOutputSurface specified by `vdpSurface` for access by
-    CUDA. A handle to the registered object is returned as `pCudaResource`.
-    The surface's intended usage is specified using `flags`, as follows:
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
-      about how this resource will be used. It is therefore assumed that
-      this resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
-      CUDA will not write to this resource.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
-      that CUDA will not read from this resource and will write over the
-      entire contents of the resource, so none of the data previously
-      stored in the resource will be preserved.
-
-    The VdpOutputSurface is presented as an array of subresources that may
-    be accessed using pointers returned by
-    :py:obj:`~.cuGraphicsSubResourceGetMappedArray`. The exact number of
-    valid `arrayIndex` values depends on the VDPAU surface format. The
-    mapping is shown in the table below. `mipLevel` must be 0.
-
-    Parameters
-    ----------
-    vdpSurface : :py:obj:`~.VdpOutputSurface`
-        The VdpOutputSurface to be registered
-    flags : unsigned int
-        Map flags
-
-    Returns
-    -------
-    CUresult
-        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
-    pCudaResource : :py:obj:`~.CUgraphicsResource`
-        Pointer to the returned object handle
-
-    See Also
-    --------
-    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`, :py:obj:`~.cudaGraphicsVDPAURegisterOutputSurface`
-    """
-    cdef ccuda.VdpOutputSurface cvdpSurface
-    if vdpSurface is None:
-        cvdpSurface = <ccuda.VdpOutputSurface><void_ptr>0
-    elif isinstance(vdpSurface, (VdpOutputSurface)):
-        pvdpSurface = int(vdpSurface)
-        cvdpSurface = <ccuda.VdpOutputSurface><void_ptr>pvdpSurface
-    else:
-        pvdpSurface = int(VdpOutputSurface(vdpSurface))
-        cvdpSurface = <ccuda.VdpOutputSurface><void_ptr>pvdpSurface
-
-    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
-    err = ccuda.cuGraphicsVDPAURegisterOutputSurface(pCudaResource._ptr, cvdpSurface, flags)
-    return (CUresult(err), pCudaResource)
-{{endif}}
-
-{{if True or 'cuGraphicsEGLRegisterImage' in found_functions}}
-
-@cython.embedsignature(True)
-def cuGraphicsEGLRegisterImage(image, unsigned int flags):
-    """ Registers an EGL image.
-
-    Registers the EGLImageKHR specified by `image` for access by CUDA. A
-    handle to the registered object is returned as `pCudaResource`.
-    Additional Mapping/Unmapping is not required for the registered
-    resource and :py:obj:`~.cuGraphicsResourceGetMappedEglFrame` can be
-    directly called on the `pCudaResource`.
-
-    The application will be responsible for synchronizing access to shared
-    objects. The application must ensure that any pending operation which
-    access the objects have completed before passing control to CUDA. This
-    may be accomplished by issuing and waiting for glFinish command on all
-    GLcontexts (for OpenGL and likewise for other APIs). The application
-    will be also responsible for ensuring that any pending operation on the
-    registered CUDA resource has completed prior to executing subsequent
-    commands in other APIs accesing the same memory objects. This can be
-    accomplished by calling cuCtxSynchronize or cuEventSynchronize
-    (preferably).
-
-    The surface's intended usage is specified using `flags`, as follows:
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
-      about how this resource will be used. It is therefore assumed that
-      this resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
-      CUDA will not write to this resource.
-
-    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
-      that CUDA will not read from this resource and will write over the
-      entire contents of the resource, so none of the data previously
-      stored in the resource will be preserved.
-
-    The EGLImageKHR is an object which can be used to create EGLImage
-    target resource. It is defined as a void pointer. typedef void*
-    EGLImageKHR
-
-    Parameters
-    ----------
-    image : :py:obj:`~.EGLImageKHR`
-        An EGLImageKHR image which can be used to create target resource.
-    flags : unsigned int
-        Map flags
-
-    Returns
-    -------
-    CUresult
-        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
-    pCudaResource : :py:obj:`~.CUgraphicsResource`
-        Pointer to the returned object handle
-
-    See Also
-    --------
-    :py:obj:`~.cuGraphicsEGLRegisterImage`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cudaGraphicsEGLRegisterImage`
-    """
-    cdef ccuda.EGLImageKHR cimage
-    if image is None:
-        cimage = <ccuda.EGLImageKHR><void_ptr>0
-    elif isinstance(image, (EGLImageKHR)):
-        pimage = int(image)
-        cimage = <ccuda.EGLImageKHR><void_ptr>pimage
-    else:
-        pimage = int(EGLImageKHR(image))
-        cimage = <ccuda.EGLImageKHR><void_ptr>pimage
-
-    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
-    err = ccuda.cuGraphicsEGLRegisterImage(pCudaResource._ptr, cimage, flags)
-    return (CUresult(err), pCudaResource)
-{{endif}}
-
-{{if True or 'cuEGLStreamConsumerConnect' in found_functions}}
-
-@cython.embedsignature(True)
-def cuEGLStreamConsumerConnect(stream):
-    """ Connect CUDA to EGLStream as a consumer.
-
-    Connect CUDA as a consumer to EGLStreamKHR specified by `stream`.
-
-    The EGLStreamKHR is an EGL object that transfers a sequence of image
-    frames from one API to another.
+    Connect CUDA as a consumer to EGLStreamKHR specified by `stream`.
+
+    The EGLStreamKHR is an EGL object that transfers a sequence of image
+    frames from one API to another.
 
     Parameters
     ----------
@@ -35254,22 +35209,21 @@ def cuEGLStreamConsumerConnect(stream):
     --------
     :py:obj:`~.cuEGLStreamConsumerConnect`, :py:obj:`~.cuEGLStreamConsumerDisconnect`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`, :py:obj:`~.cudaEGLStreamConsumerConnect`
     """
-    cdef ccuda.EGLStreamKHR cstream
+    cdef cydriver.EGLStreamKHR cystream
     if stream is None:
-        cstream = <ccuda.EGLStreamKHR><void_ptr>0
-    elif isinstance(stream, (EGLStreamKHR)):
+        cystream = <cydriver.EGLStreamKHR><void_ptr>0
+    elif isinstance(stream, (EGLStreamKHR,)):
         pstream = int(stream)
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     else:
         pstream = int(EGLStreamKHR(stream))
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
-
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
-    err = ccuda.cuEGLStreamConsumerConnect(conn._ptr, cstream)
+    err = cydriver.cuEGLStreamConsumerConnect(<cydriver.CUeglStreamConnection*>conn._ptr, cystream)
     return (CUresult(err), conn)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerConnectWithFlags' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamConsumerConnectWithFlags(stream, unsigned int flags):
@@ -35300,22 +35254,21 @@ def cuEGLStreamConsumerConnectWithFlags(stream, unsigned int flags):
     --------
     :py:obj:`~.cuEGLStreamConsumerConnect`, :py:obj:`~.cuEGLStreamConsumerDisconnect`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`, :py:obj:`~.cudaEGLStreamConsumerConnectWithFlags`
     """
-    cdef ccuda.EGLStreamKHR cstream
+    cdef cydriver.EGLStreamKHR cystream
     if stream is None:
-        cstream = <ccuda.EGLStreamKHR><void_ptr>0
-    elif isinstance(stream, (EGLStreamKHR)):
+        cystream = <cydriver.EGLStreamKHR><void_ptr>0
+    elif isinstance(stream, (EGLStreamKHR,)):
         pstream = int(stream)
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     else:
         pstream = int(EGLStreamKHR(stream))
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
-
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
-    err = ccuda.cuEGLStreamConsumerConnectWithFlags(conn._ptr, cstream, flags)
+    err = cydriver.cuEGLStreamConsumerConnectWithFlags(<cydriver.CUeglStreamConnection*>conn._ptr, cystream, flags)
     return (CUresult(err), conn)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerDisconnect' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamConsumerDisconnect(conn):
@@ -35337,22 +35290,21 @@ def cuEGLStreamConsumerDisconnect(conn):
     --------
     :py:obj:`~.cuEGLStreamConsumerConnect`, :py:obj:`~.cuEGLStreamConsumerDisconnect`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`, :py:obj:`~.cudaEGLStreamConsumerDisconnect`
     """
-    cdef ccuda.CUeglStreamConnection *cconn
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccuda.cuEGLStreamConsumerDisconnect(cconn)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    err = cydriver.cuEGLStreamConsumerDisconnect(cyconn)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerAcquireFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int timeout):
@@ -35389,44 +35341,41 @@ def cuEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int t
     --------
     :py:obj:`~.cuEGLStreamConsumerConnect`, :py:obj:`~.cuEGLStreamConsumerDisconnect`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`
     """
-    cdef ccuda.CUstream *cpStream
+    cdef cydriver.CUstream *cypStream
     if pStream is None:
-        cpStream = <ccuda.CUstream*><void_ptr>NULL
-    elif isinstance(pStream, (CUstream)):
+        cypStream = <cydriver.CUstream*><void_ptr>NULL
+    elif isinstance(pStream, (CUstream,)):
         ppStream = pStream.getPtr()
-        cpStream = <ccuda.CUstream*><void_ptr>ppStream
+        cypStream = <cydriver.CUstream*><void_ptr>ppStream
     elif isinstance(pStream, (int)):
-        cpStream = <ccuda.CUstream*><void_ptr>pStream
+        cypStream = <cydriver.CUstream*><void_ptr>pStream
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccuda.CUgraphicsResource *cpCudaResource
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, driver.CUstream'>, found " + str(type(pStream)))
+    cdef cydriver.CUgraphicsResource *cypCudaResource
     if pCudaResource is None:
-        cpCudaResource = <ccuda.CUgraphicsResource*><void_ptr>NULL
-    elif isinstance(pCudaResource, (CUgraphicsResource)):
+        cypCudaResource = <cydriver.CUgraphicsResource*><void_ptr>NULL
+    elif isinstance(pCudaResource, (CUgraphicsResource,)):
         ppCudaResource = pCudaResource.getPtr()
-        cpCudaResource = <ccuda.CUgraphicsResource*><void_ptr>ppCudaResource
+        cypCudaResource = <cydriver.CUgraphicsResource*><void_ptr>ppCudaResource
     elif isinstance(pCudaResource, (int)):
-        cpCudaResource = <ccuda.CUgraphicsResource*><void_ptr>pCudaResource
+        cypCudaResource = <cydriver.CUgraphicsResource*><void_ptr>pCudaResource
     else:
-        raise TypeError("Argument 'pCudaResource' is not instance of type (expected <class 'int, cuda.CUgraphicsResource'>, found " + str(type(pCudaResource)))
-
-    cdef ccuda.CUeglStreamConnection *cconn
+        raise TypeError("Argument 'pCudaResource' is not instance of type (expected <class 'int, driver.CUgraphicsResource'>, found " + str(type(pCudaResource)))
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccuda.cuEGLStreamConsumerAcquireFrame(cconn, cpCudaResource, cpStream, timeout)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    err = cydriver.cuEGLStreamConsumerAcquireFrame(cyconn, cypCudaResource, cypStream, timeout)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
@@ -35456,43 +35405,40 @@ def cuEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
     --------
     :py:obj:`~.cuEGLStreamConsumerConnect`, :py:obj:`~.cuEGLStreamConsumerDisconnect`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`
     """
-    cdef ccuda.CUstream *cpStream
+    cdef cydriver.CUstream *cypStream
     if pStream is None:
-        cpStream = <ccuda.CUstream*><void_ptr>NULL
-    elif isinstance(pStream, (CUstream)):
+        cypStream = <cydriver.CUstream*><void_ptr>NULL
+    elif isinstance(pStream, (CUstream,)):
         ppStream = pStream.getPtr()
-        cpStream = <ccuda.CUstream*><void_ptr>ppStream
+        cypStream = <cydriver.CUstream*><void_ptr>ppStream
     elif isinstance(pStream, (int)):
-        cpStream = <ccuda.CUstream*><void_ptr>pStream
+        cypStream = <cydriver.CUstream*><void_ptr>pStream
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccuda.CUgraphicsResource cpCudaResource
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, driver.CUstream'>, found " + str(type(pStream)))
+    cdef cydriver.CUgraphicsResource cypCudaResource
     if pCudaResource is None:
-        cpCudaResource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(pCudaResource, (CUgraphicsResource)):
+        cypCudaResource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(pCudaResource, (CUgraphicsResource,)):
         ppCudaResource = int(pCudaResource)
-        cpCudaResource = <ccuda.CUgraphicsResource><void_ptr>ppCudaResource
+        cypCudaResource = <cydriver.CUgraphicsResource><void_ptr>ppCudaResource
     else:
         ppCudaResource = int(CUgraphicsResource(pCudaResource))
-        cpCudaResource = <ccuda.CUgraphicsResource><void_ptr>ppCudaResource
-
-    cdef ccuda.CUeglStreamConnection *cconn
+        cypCudaResource = <cydriver.CUgraphicsResource><void_ptr>ppCudaResource
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccuda.cuEGLStreamConsumerReleaseFrame(cconn, cpCudaResource, cpStream)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    err = cydriver.cuEGLStreamConsumerReleaseFrame(cyconn, cypCudaResource, cypStream)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamProducerConnect(stream, width, height):
@@ -35523,42 +35469,39 @@ def cuEGLStreamProducerConnect(stream, width, height):
     --------
     :py:obj:`~.cuEGLStreamProducerConnect`, :py:obj:`~.cuEGLStreamProducerDisconnect`, :py:obj:`~.cuEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerConnect`
     """
-    cdef ccuda.EGLint cheight
+    cdef cydriver.EGLint cyheight
     if height is None:
-        cheight = <ccuda.EGLint><void_ptr>0
-    elif isinstance(height, (EGLint)):
+        cyheight = <cydriver.EGLint><void_ptr>0
+    elif isinstance(height, (EGLint,)):
         pheight = int(height)
-        cheight = <ccuda.EGLint><void_ptr>pheight
+        cyheight = <cydriver.EGLint><void_ptr>pheight
     else:
         pheight = int(EGLint(height))
-        cheight = <ccuda.EGLint><void_ptr>pheight
-
-    cdef ccuda.EGLint cwidth
+        cyheight = <cydriver.EGLint><void_ptr>pheight
+    cdef cydriver.EGLint cywidth
     if width is None:
-        cwidth = <ccuda.EGLint><void_ptr>0
-    elif isinstance(width, (EGLint)):
+        cywidth = <cydriver.EGLint><void_ptr>0
+    elif isinstance(width, (EGLint,)):
         pwidth = int(width)
-        cwidth = <ccuda.EGLint><void_ptr>pwidth
+        cywidth = <cydriver.EGLint><void_ptr>pwidth
     else:
         pwidth = int(EGLint(width))
-        cwidth = <ccuda.EGLint><void_ptr>pwidth
-
-    cdef ccuda.EGLStreamKHR cstream
+        cywidth = <cydriver.EGLint><void_ptr>pwidth
+    cdef cydriver.EGLStreamKHR cystream
     if stream is None:
-        cstream = <ccuda.EGLStreamKHR><void_ptr>0
-    elif isinstance(stream, (EGLStreamKHR)):
+        cystream = <cydriver.EGLStreamKHR><void_ptr>0
+    elif isinstance(stream, (EGLStreamKHR,)):
         pstream = int(stream)
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     else:
         pstream = int(EGLStreamKHR(stream))
-        cstream = <ccuda.EGLStreamKHR><void_ptr>pstream
-
+        cystream = <cydriver.EGLStreamKHR><void_ptr>pstream
     cdef CUeglStreamConnection conn = CUeglStreamConnection()
-    err = ccuda.cuEGLStreamProducerConnect(conn._ptr, cstream, cwidth, cheight)
+    err = cydriver.cuEGLStreamProducerConnect(<cydriver.CUeglStreamConnection*>conn._ptr, cystream, cywidth, cyheight)
     return (CUresult(err), conn)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamProducerDisconnect(conn):
@@ -35580,22 +35523,21 @@ def cuEGLStreamProducerDisconnect(conn):
     --------
     :py:obj:`~.cuEGLStreamProducerConnect`, :py:obj:`~.cuEGLStreamProducerDisconnect`, :py:obj:`~.cuEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerDisconnect`
     """
-    cdef ccuda.CUeglStreamConnection *cconn
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccuda.cuEGLStreamProducerDisconnect(cconn)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    err = cydriver.cuEGLStreamProducerDisconnect(cyconn)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamProducerPresentFrame(conn, eglframe not None : CUeglFrame, pStream):
@@ -35640,33 +35582,31 @@ def cuEGLStreamProducerPresentFrame(conn, eglframe not None : CUeglFrame, pStrea
     --------
     :py:obj:`~.cuEGLStreamProducerConnect`, :py:obj:`~.cuEGLStreamProducerDisconnect`, :py:obj:`~.cuEGLStreamProducerReturnFrame`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`
     """
-    cdef ccuda.CUstream *cpStream
+    cdef cydriver.CUstream *cypStream
     if pStream is None:
-        cpStream = <ccuda.CUstream*><void_ptr>NULL
-    elif isinstance(pStream, (CUstream)):
+        cypStream = <cydriver.CUstream*><void_ptr>NULL
+    elif isinstance(pStream, (CUstream,)):
         ppStream = pStream.getPtr()
-        cpStream = <ccuda.CUstream*><void_ptr>ppStream
+        cypStream = <cydriver.CUstream*><void_ptr>ppStream
     elif isinstance(pStream, (int)):
-        cpStream = <ccuda.CUstream*><void_ptr>pStream
+        cypStream = <cydriver.CUstream*><void_ptr>pStream
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccuda.CUeglStreamConnection *cconn
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, driver.CUstream'>, found " + str(type(pStream)))
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccuda.cuEGLStreamProducerPresentFrame(cconn, eglframe._ptr[0], cpStream)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    err = cydriver.cuEGLStreamProducerPresentFrame(cyconn, eglframe._ptr[0], cypStream)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEGLStreamProducerReturnFrame(conn, eglframe : Optional[CUeglFrame], pStream):
@@ -35695,34 +35635,32 @@ def cuEGLStreamProducerReturnFrame(conn, eglframe : Optional[CUeglFrame], pStrea
     --------
     :py:obj:`~.cuEGLStreamProducerConnect`, :py:obj:`~.cuEGLStreamProducerDisconnect`, :py:obj:`~.cuEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`
     """
-    cdef ccuda.CUstream *cpStream
+    cdef cydriver.CUstream *cypStream
     if pStream is None:
-        cpStream = <ccuda.CUstream*><void_ptr>NULL
-    elif isinstance(pStream, (CUstream)):
+        cypStream = <cydriver.CUstream*><void_ptr>NULL
+    elif isinstance(pStream, (CUstream,)):
         ppStream = pStream.getPtr()
-        cpStream = <ccuda.CUstream*><void_ptr>ppStream
+        cypStream = <cydriver.CUstream*><void_ptr>ppStream
     elif isinstance(pStream, (int)):
-        cpStream = <ccuda.CUstream*><void_ptr>pStream
+        cypStream = <cydriver.CUstream*><void_ptr>pStream
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccuda.CUeglStreamConnection *cconn
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, driver.CUstream'>, found " + str(type(pStream)))
+    cdef cydriver.CUeglStreamConnection *cyconn
     if conn is None:
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (CUeglStreamConnection)):
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (CUeglStreamConnection,)):
         pconn = conn.getPtr()
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>pconn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>pconn
     elif isinstance(conn, (int)):
-        cconn = <ccuda.CUeglStreamConnection*><void_ptr>conn
+        cyconn = <cydriver.CUeglStreamConnection*><void_ptr>conn
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    cdef ccuda.CUeglFrame* ceglframe_ptr = eglframe._ptr if eglframe != None else NULL
-    err = ccuda.cuEGLStreamProducerReturnFrame(cconn, ceglframe_ptr, cpStream)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, driver.CUeglStreamConnection'>, found " + str(type(conn)))
+    cdef cydriver.CUeglFrame* cyeglframe_ptr = eglframe._ptr if eglframe != None else NULL
+    err = cydriver.cuEGLStreamProducerReturnFrame(cyconn, cyeglframe_ptr, cypStream)
     return (CUresult(err),)
 {{endif}}
 
-{{if True or 'cuGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned int mipLevel):
@@ -35755,22 +35693,21 @@ def cuGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned i
     eglFrame : :py:obj:`~.CUeglFrame`
         None
     """
-    cdef ccuda.CUgraphicsResource cresource
+    cdef cydriver.CUgraphicsResource cyresource
     if resource is None:
-        cresource = <ccuda.CUgraphicsResource><void_ptr>0
-    elif isinstance(resource, (CUgraphicsResource)):
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>0
+    elif isinstance(resource, (CUgraphicsResource,)):
         presource = int(resource)
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     else:
         presource = int(CUgraphicsResource(resource))
-        cresource = <ccuda.CUgraphicsResource><void_ptr>presource
-
+        cyresource = <cydriver.CUgraphicsResource><void_ptr>presource
     cdef CUeglFrame eglFrame = CUeglFrame()
-    err = ccuda.cuGraphicsResourceGetMappedEglFrame(eglFrame._ptr, cresource, index, mipLevel)
+    err = cydriver.cuGraphicsResourceGetMappedEglFrame(<cydriver.CUeglFrame*>eglFrame._ptr, cyresource, index, mipLevel)
     return (CUresult(err), eglFrame)
 {{endif}}
 
-{{if True or 'cuEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuEventCreateFromEGLSync(eglSync, unsigned int flags):
@@ -35813,22 +35750,21 @@ def cuEventCreateFromEGLSync(eglSync, unsigned int flags):
     --------
     :py:obj:`~.cuEventQuery`, :py:obj:`~.cuEventSynchronize`, :py:obj:`~.cuEventDestroy`
     """
-    cdef ccuda.EGLSyncKHR ceglSync
+    cdef cydriver.EGLSyncKHR cyeglSync
     if eglSync is None:
-        ceglSync = <ccuda.EGLSyncKHR><void_ptr>0
-    elif isinstance(eglSync, (EGLSyncKHR)):
+        cyeglSync = <cydriver.EGLSyncKHR><void_ptr>0
+    elif isinstance(eglSync, (EGLSyncKHR,)):
         peglSync = int(eglSync)
-        ceglSync = <ccuda.EGLSyncKHR><void_ptr>peglSync
+        cyeglSync = <cydriver.EGLSyncKHR><void_ptr>peglSync
     else:
         peglSync = int(EGLSyncKHR(eglSync))
-        ceglSync = <ccuda.EGLSyncKHR><void_ptr>peglSync
-
+        cyeglSync = <cydriver.EGLSyncKHR><void_ptr>peglSync
     cdef CUevent phEvent = CUevent()
-    err = ccuda.cuEventCreateFromEGLSync(phEvent._ptr, ceglSync, flags)
+    err = cydriver.cuEventCreateFromEGLSync(<cydriver.CUevent*>phEvent._ptr, cyeglSync, flags)
     return (CUresult(err), phEvent)
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterBuffer' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuGraphicsGLRegisterBuffer(buffer, unsigned int Flags):
@@ -35869,22 +35805,21 @@ def cuGraphicsGLRegisterBuffer(buffer, unsigned int Flags):
     --------
     :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsResourceGetMappedPointer`, :py:obj:`~.cudaGraphicsGLRegisterBuffer`
     """
-    cdef ccuda.GLuint cbuffer
+    cdef cydriver.GLuint cybuffer
     if buffer is None:
-        cbuffer = <ccuda.GLuint><void_ptr>0
-    elif isinstance(buffer, (GLuint)):
+        cybuffer = <cydriver.GLuint><void_ptr>0
+    elif isinstance(buffer, (GLuint,)):
         pbuffer = int(buffer)
-        cbuffer = <ccuda.GLuint><void_ptr>pbuffer
+        cybuffer = <cydriver.GLuint><void_ptr>pbuffer
     else:
         pbuffer = int(GLuint(buffer))
-        cbuffer = <ccuda.GLuint><void_ptr>pbuffer
-
+        cybuffer = <cydriver.GLuint><void_ptr>pbuffer
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
-    err = ccuda.cuGraphicsGLRegisterBuffer(pCudaResource._ptr, cbuffer, Flags)
+    err = cydriver.cuGraphicsGLRegisterBuffer(<cydriver.CUgraphicsResource*>pCudaResource._ptr, cybuffer, Flags)
     return (CUresult(err), pCudaResource)
 {{endif}}
 
-{{if True or 'cuGraphicsGLRegisterImage' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuGraphicsGLRegisterImage(image, target, unsigned int Flags):
@@ -35960,32 +35895,30 @@ def cuGraphicsGLRegisterImage(image, target, unsigned int Flags):
     --------
     :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaGraphicsGLRegisterImage`
     """
-    cdef ccuda.GLenum ctarget
+    cdef cydriver.GLenum cytarget
     if target is None:
-        ctarget = <ccuda.GLenum><void_ptr>0
-    elif isinstance(target, (GLenum)):
+        cytarget = <cydriver.GLenum><void_ptr>0
+    elif isinstance(target, (GLenum,)):
         ptarget = int(target)
-        ctarget = <ccuda.GLenum><void_ptr>ptarget
+        cytarget = <cydriver.GLenum><void_ptr>ptarget
     else:
         ptarget = int(GLenum(target))
-        ctarget = <ccuda.GLenum><void_ptr>ptarget
-
-    cdef ccuda.GLuint cimage
+        cytarget = <cydriver.GLenum><void_ptr>ptarget
+    cdef cydriver.GLuint cyimage
     if image is None:
-        cimage = <ccuda.GLuint><void_ptr>0
-    elif isinstance(image, (GLuint)):
+        cyimage = <cydriver.GLuint><void_ptr>0
+    elif isinstance(image, (GLuint,)):
         pimage = int(image)
-        cimage = <ccuda.GLuint><void_ptr>pimage
+        cyimage = <cydriver.GLuint><void_ptr>pimage
     else:
         pimage = int(GLuint(image))
-        cimage = <ccuda.GLuint><void_ptr>pimage
-
+        cyimage = <cydriver.GLuint><void_ptr>pimage
     cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
-    err = ccuda.cuGraphicsGLRegisterImage(pCudaResource._ptr, cimage, ctarget, Flags)
+    err = cydriver.cuGraphicsGLRegisterImage(<cydriver.CUgraphicsResource*>pCudaResource._ptr, cyimage, cytarget, Flags)
     return (CUresult(err), pCudaResource)
 {{endif}}
 
-{{if True or 'cuGLGetDevices_v2' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cuGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : CUGLDeviceList):
@@ -36036,27 +35969,267 @@ def cuGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : CUGLDevic
 
     """
     cdef unsigned int pCudaDeviceCount = 0
-    cdef ccuda.CUdevice* cpCudaDevices = NULL
+    cdef cydriver.CUdevice* cypCudaDevices = NULL
     pypCudaDevices = []
     if cudaDeviceCount != 0:
-        cpCudaDevices = <ccuda.CUdevice*>calloc(cudaDeviceCount, sizeof(ccuda.CUdevice))
-        if cpCudaDevices is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(cudaDeviceCount) + 'x' + str(sizeof(ccuda.CUdevice)))
-    cdef ccuda.CUGLDeviceList cdeviceList = deviceList.value
-    err = ccuda.cuGLGetDevices(&pCudaDeviceCount, cpCudaDevices, cudaDeviceCount, cdeviceList)
+        cypCudaDevices = <cydriver.CUdevice*>calloc(cudaDeviceCount, sizeof(cydriver.CUdevice))
+        if cypCudaDevices is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(cudaDeviceCount) + 'x' + str(sizeof(cydriver.CUdevice)))
+    cdef cydriver.CUGLDeviceList cydeviceList = deviceList.value
+    err = cydriver.cuGLGetDevices(&pCudaDeviceCount, cypCudaDevices, cudaDeviceCount, cydeviceList)
     if CUresult(err) == CUresult(0):
-        pypCudaDevices = [CUdevice(init_value=<void_ptr>cpCudaDevices[idx]) for idx in range(cudaDeviceCount)]
-    if cpCudaDevices is not NULL:
-        free(cpCudaDevices)
+        pypCudaDevices = [CUdevice(init_value=<void_ptr>cypCudaDevices[idx]) for idx in range(cudaDeviceCount)]
+    if cypCudaDevices is not NULL:
+        free(cypCudaDevices)
     return (CUresult(err), pCudaDeviceCount, pypCudaDevices)
 {{endif}}
 
+{{if True}}
+
 @cython.embedsignature(True)
-def sizeof(objType):
-    """ Returns the size of provided CUDA Python structure in bytes
+def cuVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
+    """ Gets the CUDA device associated with a VDPAU device.
 
-    Parameters
-    ----------
+    Returns in `*pDevice` the CUDA device associated with a `vdpDevice`, if
+    applicable.
+
+    Parameters
+    ----------
+    vdpDevice : :py:obj:`~.VdpDevice`
+        A VdpDevice handle
+    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
+        VDPAU's VdpGetProcAddress function pointer
+
+    Returns
+    -------
+    CUresult
+        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`
+    pDevice : :py:obj:`~.CUdevice`
+        Device associated with vdpDevice
+
+    See Also
+    --------
+    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaVDPAUGetDevice`
+    """
+    cdef cydriver.VdpGetProcAddress *cyvdpGetProcAddress
+    if vdpGetProcAddress is None:
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>NULL
+    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress,)):
+        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
+    elif isinstance(vdpGetProcAddress, (int)):
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
+    else:
+        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, driver.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
+    cdef cydriver.VdpDevice cyvdpDevice
+    if vdpDevice is None:
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>0
+    elif isinstance(vdpDevice, (VdpDevice,)):
+        pvdpDevice = int(vdpDevice)
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>pvdpDevice
+    else:
+        pvdpDevice = int(VdpDevice(vdpDevice))
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>pvdpDevice
+    cdef CUdevice pDevice = CUdevice()
+    err = cydriver.cuVDPAUGetDevice(<cydriver.CUdevice*>pDevice._ptr, cyvdpDevice, cyvdpGetProcAddress)
+    return (CUresult(err), pDevice)
+{{endif}}
+
+{{if True}}
+
+@cython.embedsignature(True)
+def cuVDPAUCtxCreate(unsigned int flags, device, vdpDevice, vdpGetProcAddress):
+    """ Create a CUDA context for interoperability with VDPAU.
+
+    Creates a new CUDA context, initializes VDPAU interoperability, and
+    associates the CUDA context with the calling thread. It must be called
+    before performing any other VDPAU interoperability operations. It may
+    fail if the needed VDPAU driver facilities are not available. For usage
+    of the `flags` parameter, see :py:obj:`~.cuCtxCreate()`.
+
+    Parameters
+    ----------
+    flags : unsigned int
+        Options for CUDA context creation
+    device : :py:obj:`~.CUdevice`
+        Device on which to create the context
+    vdpDevice : :py:obj:`~.VdpDevice`
+        The VdpDevice to interop with
+    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
+        VDPAU's VdpGetProcAddress function pointer
+
+    Returns
+    -------
+    CUresult
+        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_DEINITIALIZED`, :py:obj:`~.CUDA_ERROR_NOT_INITIALIZED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`, :py:obj:`~.CUDA_ERROR_INVALID_VALUE`, :py:obj:`~.CUDA_ERROR_OUT_OF_MEMORY`
+    pCtx : :py:obj:`~.CUcontext`
+        Returned CUDA context
+
+    See Also
+    --------
+    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`
+    """
+    cdef cydriver.VdpGetProcAddress *cyvdpGetProcAddress
+    if vdpGetProcAddress is None:
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>NULL
+    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress,)):
+        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
+    elif isinstance(vdpGetProcAddress, (int)):
+        cyvdpGetProcAddress = <cydriver.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
+    else:
+        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, driver.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
+    cdef cydriver.VdpDevice cyvdpDevice
+    if vdpDevice is None:
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>0
+    elif isinstance(vdpDevice, (VdpDevice,)):
+        pvdpDevice = int(vdpDevice)
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>pvdpDevice
+    else:
+        pvdpDevice = int(VdpDevice(vdpDevice))
+        cyvdpDevice = <cydriver.VdpDevice><void_ptr>pvdpDevice
+    cdef cydriver.CUdevice cydevice
+    if device is None:
+        cydevice = <cydriver.CUdevice>0
+    elif isinstance(device, (CUdevice,)):
+        pdevice = int(device)
+        cydevice = <cydriver.CUdevice>pdevice
+    else:
+        pdevice = int(CUdevice(device))
+        cydevice = <cydriver.CUdevice>pdevice
+    cdef CUcontext pCtx = CUcontext()
+    err = cydriver.cuVDPAUCtxCreate(<cydriver.CUcontext*>pCtx._ptr, flags, cydevice, cyvdpDevice, cyvdpGetProcAddress)
+    return (CUresult(err), pCtx)
+{{endif}}
+
+{{if True}}
+
+@cython.embedsignature(True)
+def cuGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
+    """ Registers a VDPAU VdpVideoSurface object.
+
+    Registers the VdpVideoSurface specified by `vdpSurface` for access by
+    CUDA. A handle to the registered object is returned as `pCudaResource`.
+    The surface's intended usage is specified using `flags`, as follows:
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
+      about how this resource will be used. It is therefore assumed that
+      this resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
+      CUDA will not write to this resource.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
+      that CUDA will not read from this resource and will write over the
+      entire contents of the resource, so none of the data previously
+      stored in the resource will be preserved.
+
+    The VdpVideoSurface is presented as an array of subresources that may
+    be accessed using pointers returned by
+    :py:obj:`~.cuGraphicsSubResourceGetMappedArray`. The exact number of
+    valid `arrayIndex` values depends on the VDPAU surface format. The
+    mapping is shown in the table below. `mipLevel` must be 0.
+
+    Parameters
+    ----------
+    vdpSurface : :py:obj:`~.VdpVideoSurface`
+        The VdpVideoSurface to be registered
+    flags : unsigned int
+        Map flags
+
+    Returns
+    -------
+    CUresult
+        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
+    pCudaResource : :py:obj:`~.CUgraphicsResource`
+        Pointer to the returned object handle
+
+    See Also
+    --------
+    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`, :py:obj:`~.cudaGraphicsVDPAURegisterVideoSurface`
+    """
+    cdef cydriver.VdpVideoSurface cyvdpSurface
+    if vdpSurface is None:
+        cyvdpSurface = <cydriver.VdpVideoSurface><void_ptr>0
+    elif isinstance(vdpSurface, (VdpVideoSurface,)):
+        pvdpSurface = int(vdpSurface)
+        cyvdpSurface = <cydriver.VdpVideoSurface><void_ptr>pvdpSurface
+    else:
+        pvdpSurface = int(VdpVideoSurface(vdpSurface))
+        cyvdpSurface = <cydriver.VdpVideoSurface><void_ptr>pvdpSurface
+    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
+    err = cydriver.cuGraphicsVDPAURegisterVideoSurface(<cydriver.CUgraphicsResource*>pCudaResource._ptr, cyvdpSurface, flags)
+    return (CUresult(err), pCudaResource)
+{{endif}}
+
+{{if True}}
+
+@cython.embedsignature(True)
+def cuGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
+    """ Registers a VDPAU VdpOutputSurface object.
+
+    Registers the VdpOutputSurface specified by `vdpSurface` for access by
+    CUDA. A handle to the registered object is returned as `pCudaResource`.
+    The surface's intended usage is specified using `flags`, as follows:
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`: Specifies no hints
+      about how this resource will be used. It is therefore assumed that
+      this resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`: Specifies that
+      CUDA will not write to this resource.
+
+    - :py:obj:`~.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`: Specifies
+      that CUDA will not read from this resource and will write over the
+      entire contents of the resource, so none of the data previously
+      stored in the resource will be preserved.
+
+    The VdpOutputSurface is presented as an array of subresources that may
+    be accessed using pointers returned by
+    :py:obj:`~.cuGraphicsSubResourceGetMappedArray`. The exact number of
+    valid `arrayIndex` values depends on the VDPAU surface format. The
+    mapping is shown in the table below. `mipLevel` must be 0.
+
+    Parameters
+    ----------
+    vdpSurface : :py:obj:`~.VdpOutputSurface`
+        The VdpOutputSurface to be registered
+    flags : unsigned int
+        Map flags
+
+    Returns
+    -------
+    CUresult
+        :py:obj:`~.CUDA_SUCCESS`, :py:obj:`~.CUDA_ERROR_INVALID_HANDLE`, :py:obj:`~.CUDA_ERROR_ALREADY_MAPPED`, :py:obj:`~.CUDA_ERROR_INVALID_CONTEXT`,
+    pCudaResource : :py:obj:`~.CUgraphicsResource`
+        Pointer to the returned object handle
+
+    See Also
+    --------
+    :py:obj:`~.cuCtxCreate`, :py:obj:`~.cuVDPAUCtxCreate`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cuGraphicsUnregisterResource`, :py:obj:`~.cuGraphicsResourceSetMapFlags`, :py:obj:`~.cuGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuVDPAUGetDevice`, :py:obj:`~.cudaGraphicsVDPAURegisterOutputSurface`
+    """
+    cdef cydriver.VdpOutputSurface cyvdpSurface
+    if vdpSurface is None:
+        cyvdpSurface = <cydriver.VdpOutputSurface><void_ptr>0
+    elif isinstance(vdpSurface, (VdpOutputSurface,)):
+        pvdpSurface = int(vdpSurface)
+        cyvdpSurface = <cydriver.VdpOutputSurface><void_ptr>pvdpSurface
+    else:
+        pvdpSurface = int(VdpOutputSurface(vdpSurface))
+        cyvdpSurface = <cydriver.VdpOutputSurface><void_ptr>pvdpSurface
+    cdef CUgraphicsResource pCudaResource = CUgraphicsResource()
+    err = cydriver.cuGraphicsVDPAURegisterOutputSurface(<cydriver.CUgraphicsResource*>pCudaResource._ptr, cyvdpSurface, flags)
+    return (CUresult(err), pCudaResource)
+{{endif}}
+
+@cython.embedsignature(True)
+def sizeof(objType):
+    """ Returns the size of provided CUDA Python structure in bytes
+
+    Parameters
+    ----------
     objType : Any
         CUDA Python object
 
@@ -36065,517 +36238,517 @@ def sizeof(objType):
     lowered_name : int
         The size of `objType` in bytes
     """
-    {{if 'CUuuid_st' in found_types}}
-    if objType == CUuuid_st:
-        return sizeof(ccuda.CUuuid_st){{endif}}
-    {{if 'CUipcEventHandle_st' in found_types}}
-    if objType == CUipcEventHandle_st:
-        return sizeof(ccuda.CUipcEventHandle_st){{endif}}
-    {{if 'CUipcMemHandle_st' in found_types}}
-    if objType == CUipcMemHandle_st:
-        return sizeof(ccuda.CUipcMemHandle_st){{endif}}
-    {{if 'CUstreamBatchMemOpParams_union' in found_types}}
-    if objType == CUstreamBatchMemOpParams_union:
-        return sizeof(ccuda.CUstreamBatchMemOpParams_union){{endif}}
-    {{if 'CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st){{endif}}
-    {{if 'CUdevprop_st' in found_types}}
-    if objType == CUdevprop_st:
-        return sizeof(ccuda.CUdevprop_st){{endif}}
-    {{if 'CUaccessPolicyWindow_st' in found_types}}
-    if objType == CUaccessPolicyWindow_st:
-        return sizeof(ccuda.CUaccessPolicyWindow_st){{endif}}
-    {{if 'CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_KERNEL_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_KERNEL_NODE_PARAMS_st){{endif}}
-    {{if 'CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_MEMSET_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_MEMSET_NODE_PARAMS_st){{endif}}
-    {{if 'CUDA_HOST_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_HOST_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_HOST_NODE_PARAMS_st){{endif}}
-    {{if 'CUlaunchAttributeValue_union' in found_types}}
-    if objType == CUlaunchAttributeValue_union:
-        return sizeof(ccuda.CUlaunchAttributeValue_union){{endif}}
-    {{if 'CUlaunchAttribute_st' in found_types}}
-    if objType == CUlaunchAttribute_st:
-        return sizeof(ccuda.CUlaunchAttribute_st){{endif}}
-    {{if 'CUlaunchConfig_st' in found_types}}
-    if objType == CUlaunchConfig_st:
-        return sizeof(ccuda.CUlaunchConfig_st){{endif}}
-    {{if 'CUexecAffinitySmCount_st' in found_types}}
-    if objType == CUexecAffinitySmCount_st:
-        return sizeof(ccuda.CUexecAffinitySmCount_st){{endif}}
-    {{if 'CUexecAffinityParam_st' in found_types}}
-    if objType == CUexecAffinityParam_st:
-        return sizeof(ccuda.CUexecAffinityParam_st){{endif}}
-    {{if 'CUDA_MEMCPY2D_st' in found_types}}
-    if objType == CUDA_MEMCPY2D_st:
-        return sizeof(ccuda.CUDA_MEMCPY2D_st){{endif}}
-    {{if 'CUDA_MEMCPY3D_st' in found_types}}
-    if objType == CUDA_MEMCPY3D_st:
-        return sizeof(ccuda.CUDA_MEMCPY3D_st){{endif}}
-    {{if 'CUDA_MEMCPY3D_PEER_st' in found_types}}
-    if objType == CUDA_MEMCPY3D_PEER_st:
-        return sizeof(ccuda.CUDA_MEMCPY3D_PEER_st){{endif}}
-    {{if 'CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
-    if objType == CUDA_ARRAY_DESCRIPTOR_st:
-        return sizeof(ccuda.CUDA_ARRAY_DESCRIPTOR_st){{endif}}
-    {{if 'CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
-    if objType == CUDA_ARRAY3D_DESCRIPTOR_st:
-        return sizeof(ccuda.CUDA_ARRAY3D_DESCRIPTOR_st){{endif}}
-    {{if 'CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
-    if objType == CUDA_ARRAY_SPARSE_PROPERTIES_st:
-        return sizeof(ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_st){{endif}}
-    {{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
-    if objType == CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
-        return sizeof(ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st){{endif}}
-    {{if 'CUDA_RESOURCE_DESC_st' in found_types}}
-    if objType == CUDA_RESOURCE_DESC_st:
-        return sizeof(ccuda.CUDA_RESOURCE_DESC_st){{endif}}
-    {{if 'CUDA_TEXTURE_DESC_st' in found_types}}
-    if objType == CUDA_TEXTURE_DESC_st:
-        return sizeof(ccuda.CUDA_TEXTURE_DESC_st){{endif}}
-    {{if 'CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
-    if objType == CUDA_RESOURCE_VIEW_DESC_st:
-        return sizeof(ccuda.CUDA_RESOURCE_VIEW_DESC_st){{endif}}
-    {{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
-    if objType == CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
-        return sizeof(ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st){{endif}}
-    {{if 'CUDA_LAUNCH_PARAMS_st' in found_types}}
-    if objType == CUDA_LAUNCH_PARAMS_st:
-        return sizeof(ccuda.CUDA_LAUNCH_PARAMS_st){{endif}}
-    {{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
-    if objType == CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st){{endif}}
-    {{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
-    if objType == CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st){{endif}}
-    {{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
-    if objType == CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st){{endif}}
-    {{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
-    if objType == CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st){{endif}}
-    {{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
-    if objType == CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st){{endif}}
-    {{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
-    if objType == CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st){{endif}}
-    {{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st){{endif}}
-    {{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st){{endif}}
-    {{if 'CUarrayMapInfo_st' in found_types}}
-    if objType == CUarrayMapInfo_st:
-        return sizeof(ccuda.CUarrayMapInfo_st){{endif}}
-    {{if 'CUmemLocation_st' in found_types}}
-    if objType == CUmemLocation_st:
-        return sizeof(ccuda.CUmemLocation_st){{endif}}
-    {{if 'CUmemAllocationProp_st' in found_types}}
-    if objType == CUmemAllocationProp_st:
-        return sizeof(ccuda.CUmemAllocationProp_st){{endif}}
-    {{if 'CUmemAccessDesc_st' in found_types}}
-    if objType == CUmemAccessDesc_st:
-        return sizeof(ccuda.CUmemAccessDesc_st){{endif}}
-    {{if 'CUmemPoolProps_st' in found_types}}
-    if objType == CUmemPoolProps_st:
-        return sizeof(ccuda.CUmemPoolProps_st){{endif}}
-    {{if 'CUmemPoolPtrExportData_st' in found_types}}
-    if objType == CUmemPoolPtrExportData_st:
-        return sizeof(ccuda.CUmemPoolPtrExportData_st){{endif}}
-    {{if 'CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
-    if objType == CUDA_MEM_ALLOC_NODE_PARAMS_st:
-        return sizeof(ccuda.CUDA_MEM_ALLOC_NODE_PARAMS_st){{endif}}
-    {{if True or 'CUeglFrame_st' in found_types}}
-    if objType == CUeglFrame_st:
-        return sizeof(ccuda.CUeglFrame_st){{endif}}
+    {{if 'cuuint32_t' in found_types}}
+    if objType == cuuint32_t:
+        return sizeof(cydriver.cuuint32_t){{endif}}
+    {{if 'cuuint64_t' in found_types}}
+    if objType == cuuint64_t:
+        return sizeof(cydriver.cuuint64_t){{endif}}
+    {{if 'CUdeviceptr_v2' in found_types}}
+    if objType == CUdeviceptr_v2:
+        return sizeof(cydriver.CUdeviceptr_v2){{endif}}
+    {{if 'CUdeviceptr' in found_types}}
+    if objType == CUdeviceptr:
+        return sizeof(cydriver.CUdeviceptr){{endif}}
+    {{if 'CUdevice_v1' in found_types}}
+    if objType == CUdevice_v1:
+        return sizeof(cydriver.CUdevice_v1){{endif}}
+    {{if 'CUdevice' in found_types}}
+    if objType == CUdevice:
+        return sizeof(cydriver.CUdevice){{endif}}
     {{if 'CUcontext' in found_types}}
     if objType == CUcontext:
-        return sizeof(ccuda.CUcontext){{endif}}
+        return sizeof(cydriver.CUcontext){{endif}}
     {{if 'CUmodule' in found_types}}
     if objType == CUmodule:
-        return sizeof(ccuda.CUmodule){{endif}}
+        return sizeof(cydriver.CUmodule){{endif}}
     {{if 'CUfunction' in found_types}}
     if objType == CUfunction:
-        return sizeof(ccuda.CUfunction){{endif}}
+        return sizeof(cydriver.CUfunction){{endif}}
     {{if 'CUarray' in found_types}}
     if objType == CUarray:
-        return sizeof(ccuda.CUarray){{endif}}
+        return sizeof(cydriver.CUarray){{endif}}
     {{if 'CUmipmappedArray' in found_types}}
     if objType == CUmipmappedArray:
-        return sizeof(ccuda.CUmipmappedArray){{endif}}
+        return sizeof(cydriver.CUmipmappedArray){{endif}}
     {{if 'CUtexref' in found_types}}
     if objType == CUtexref:
-        return sizeof(ccuda.CUtexref){{endif}}
+        return sizeof(cydriver.CUtexref){{endif}}
     {{if 'CUsurfref' in found_types}}
     if objType == CUsurfref:
-        return sizeof(ccuda.CUsurfref){{endif}}
+        return sizeof(cydriver.CUsurfref){{endif}}
     {{if 'CUevent' in found_types}}
     if objType == CUevent:
-        return sizeof(ccuda.CUevent){{endif}}
+        return sizeof(cydriver.CUevent){{endif}}
     {{if 'CUstream' in found_types}}
     if objType == CUstream:
-        return sizeof(ccuda.CUstream){{endif}}
+        return sizeof(cydriver.CUstream){{endif}}
     {{if 'CUgraphicsResource' in found_types}}
     if objType == CUgraphicsResource:
-        return sizeof(ccuda.CUgraphicsResource){{endif}}
+        return sizeof(cydriver.CUgraphicsResource){{endif}}
+    {{if 'CUtexObject_v1' in found_types}}
+    if objType == CUtexObject_v1:
+        return sizeof(cydriver.CUtexObject_v1){{endif}}
+    {{if 'CUtexObject' in found_types}}
+    if objType == CUtexObject:
+        return sizeof(cydriver.CUtexObject){{endif}}
+    {{if 'CUsurfObject_v1' in found_types}}
+    if objType == CUsurfObject_v1:
+        return sizeof(cydriver.CUsurfObject_v1){{endif}}
+    {{if 'CUsurfObject' in found_types}}
+    if objType == CUsurfObject:
+        return sizeof(cydriver.CUsurfObject){{endif}}
     {{if 'CUexternalMemory' in found_types}}
     if objType == CUexternalMemory:
-        return sizeof(ccuda.CUexternalMemory){{endif}}
+        return sizeof(cydriver.CUexternalMemory){{endif}}
     {{if 'CUexternalSemaphore' in found_types}}
     if objType == CUexternalSemaphore:
-        return sizeof(ccuda.CUexternalSemaphore){{endif}}
+        return sizeof(cydriver.CUexternalSemaphore){{endif}}
     {{if 'CUgraph' in found_types}}
     if objType == CUgraph:
-        return sizeof(ccuda.CUgraph){{endif}}
+        return sizeof(cydriver.CUgraph){{endif}}
     {{if 'CUgraphNode' in found_types}}
     if objType == CUgraphNode:
-        return sizeof(ccuda.CUgraphNode){{endif}}
+        return sizeof(cydriver.CUgraphNode){{endif}}
     {{if 'CUgraphExec' in found_types}}
     if objType == CUgraphExec:
-        return sizeof(ccuda.CUgraphExec){{endif}}
+        return sizeof(cydriver.CUgraphExec){{endif}}
     {{if 'CUmemoryPool' in found_types}}
     if objType == CUmemoryPool:
-        return sizeof(ccuda.CUmemoryPool){{endif}}
+        return sizeof(cydriver.CUmemoryPool){{endif}}
     {{if 'CUuserObject' in found_types}}
     if objType == CUuserObject:
-        return sizeof(ccuda.CUuserObject){{endif}}
-    {{if 'CUlinkState' in found_types}}
-    if objType == CUlinkState:
-        return sizeof(ccuda.CUlinkState){{endif}}
-    {{if True or 'EGLImageKHR' in found_types}}
-    if objType == EGLImageKHR:
-        return sizeof(ccuda.EGLImageKHR){{endif}}
-    {{if True or 'EGLStreamKHR' in found_types}}
-    if objType == EGLStreamKHR:
-        return sizeof(ccuda.EGLStreamKHR){{endif}}
-    {{if True or 'EGLSyncKHR' in found_types}}
-    if objType == EGLSyncKHR:
-        return sizeof(ccuda.EGLSyncKHR){{endif}}
-    {{if True or 'CUeglStreamConnection' in found_types}}
-    if objType == CUeglStreamConnection:
-        return sizeof(ccuda.CUeglStreamConnection){{endif}}
-    {{if 'CUhostFn' in found_types}}
-    if objType == CUhostFn:
-        return sizeof(ccuda.CUhostFn){{endif}}
-    {{if 'CUstreamCallback' in found_types}}
-    if objType == CUstreamCallback:
-        return sizeof(ccuda.CUstreamCallback){{endif}}
-    {{if 'CUoccupancyB2DSize' in found_types}}
-    if objType == CUoccupancyB2DSize:
-        return sizeof(ccuda.CUoccupancyB2DSize){{endif}}
+        return sizeof(cydriver.CUuserObject){{endif}}
+    {{if 'struct CUuuid_st' in found_types}}
+    if objType == CUuuid_st:
+        return sizeof(cydriver.CUuuid_st){{endif}}
     {{if 'CUuuid' in found_types}}
     if objType == CUuuid:
-        return sizeof(ccuda.CUuuid){{endif}}
+        return sizeof(cydriver.CUuuid){{endif}}
+    {{if 'struct CUipcEventHandle_st' in found_types}}
+    if objType == CUipcEventHandle_st:
+        return sizeof(cydriver.CUipcEventHandle_st){{endif}}
     {{if 'CUipcEventHandle_v1' in found_types}}
     if objType == CUipcEventHandle_v1:
-        return sizeof(ccuda.CUipcEventHandle_v1){{endif}}
+        return sizeof(cydriver.CUipcEventHandle_v1){{endif}}
     {{if 'CUipcEventHandle' in found_types}}
     if objType == CUipcEventHandle:
-        return sizeof(ccuda.CUipcEventHandle){{endif}}
+        return sizeof(cydriver.CUipcEventHandle){{endif}}
+    {{if 'struct CUipcMemHandle_st' in found_types}}
+    if objType == CUipcMemHandle_st:
+        return sizeof(cydriver.CUipcMemHandle_st){{endif}}
     {{if 'CUipcMemHandle_v1' in found_types}}
     if objType == CUipcMemHandle_v1:
-        return sizeof(ccuda.CUipcMemHandle_v1){{endif}}
+        return sizeof(cydriver.CUipcMemHandle_v1){{endif}}
     {{if 'CUipcMemHandle' in found_types}}
     if objType == CUipcMemHandle:
-        return sizeof(ccuda.CUipcMemHandle){{endif}}
+        return sizeof(cydriver.CUipcMemHandle){{endif}}
+    {{if 'union CUstreamBatchMemOpParams_union' in found_types}}
+    if objType == CUstreamBatchMemOpParams_union:
+        return sizeof(cydriver.CUstreamBatchMemOpParams_union){{endif}}
     {{if 'CUstreamBatchMemOpParams_v1' in found_types}}
     if objType == CUstreamBatchMemOpParams_v1:
-        return sizeof(ccuda.CUstreamBatchMemOpParams_v1){{endif}}
+        return sizeof(cydriver.CUstreamBatchMemOpParams_v1){{endif}}
     {{if 'CUstreamBatchMemOpParams' in found_types}}
     if objType == CUstreamBatchMemOpParams:
-        return sizeof(ccuda.CUstreamBatchMemOpParams){{endif}}
+        return sizeof(cydriver.CUstreamBatchMemOpParams){{endif}}
+    {{if 'struct CUDA_BATCH_MEM_OP_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_BATCH_MEM_OP_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_BATCH_MEM_OP_NODE_PARAMS' in found_types}}
     if objType == CUDA_BATCH_MEM_OP_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_BATCH_MEM_OP_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_BATCH_MEM_OP_NODE_PARAMS){{endif}}
+    {{if 'struct CUdevprop_st' in found_types}}
+    if objType == CUdevprop_st:
+        return sizeof(cydriver.CUdevprop_st){{endif}}
     {{if 'CUdevprop_v1' in found_types}}
     if objType == CUdevprop_v1:
-        return sizeof(ccuda.CUdevprop_v1){{endif}}
+        return sizeof(cydriver.CUdevprop_v1){{endif}}
     {{if 'CUdevprop' in found_types}}
     if objType == CUdevprop:
-        return sizeof(ccuda.CUdevprop){{endif}}
+        return sizeof(cydriver.CUdevprop){{endif}}
+    {{if 'CUlinkState' in found_types}}
+    if objType == CUlinkState:
+        return sizeof(cydriver.CUlinkState){{endif}}
+    {{if 'CUhostFn' in found_types}}
+    if objType == CUhostFn:
+        return sizeof(cydriver.CUhostFn){{endif}}
+    {{if 'struct CUaccessPolicyWindow_st' in found_types}}
+    if objType == CUaccessPolicyWindow_st:
+        return sizeof(cydriver.CUaccessPolicyWindow_st){{endif}}
     {{if 'CUaccessPolicyWindow_v1' in found_types}}
     if objType == CUaccessPolicyWindow_v1:
-        return sizeof(ccuda.CUaccessPolicyWindow_v1){{endif}}
+        return sizeof(cydriver.CUaccessPolicyWindow_v1){{endif}}
     {{if 'CUaccessPolicyWindow' in found_types}}
     if objType == CUaccessPolicyWindow:
-        return sizeof(ccuda.CUaccessPolicyWindow){{endif}}
+        return sizeof(cydriver.CUaccessPolicyWindow){{endif}}
+    {{if 'struct CUDA_KERNEL_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_KERNEL_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_KERNEL_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_KERNEL_NODE_PARAMS_v1' in found_types}}
     if objType == CUDA_KERNEL_NODE_PARAMS_v1:
-        return sizeof(ccuda.CUDA_KERNEL_NODE_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_KERNEL_NODE_PARAMS_v1){{endif}}
     {{if 'CUDA_KERNEL_NODE_PARAMS' in found_types}}
     if objType == CUDA_KERNEL_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_KERNEL_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_KERNEL_NODE_PARAMS){{endif}}
+    {{if 'struct CUDA_MEMSET_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_MEMSET_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_MEMSET_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_MEMSET_NODE_PARAMS_v1' in found_types}}
     if objType == CUDA_MEMSET_NODE_PARAMS_v1:
-        return sizeof(ccuda.CUDA_MEMSET_NODE_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_MEMSET_NODE_PARAMS_v1){{endif}}
     {{if 'CUDA_MEMSET_NODE_PARAMS' in found_types}}
     if objType == CUDA_MEMSET_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_MEMSET_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_MEMSET_NODE_PARAMS){{endif}}
+    {{if 'struct CUDA_HOST_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_HOST_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_HOST_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_HOST_NODE_PARAMS_v1' in found_types}}
     if objType == CUDA_HOST_NODE_PARAMS_v1:
-        return sizeof(ccuda.CUDA_HOST_NODE_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_HOST_NODE_PARAMS_v1){{endif}}
     {{if 'CUDA_HOST_NODE_PARAMS' in found_types}}
     if objType == CUDA_HOST_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_HOST_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_HOST_NODE_PARAMS){{endif}}
+    {{if 'union CUlaunchAttributeValue_union' in found_types}}
+    if objType == CUlaunchAttributeValue_union:
+        return sizeof(cydriver.CUlaunchAttributeValue_union){{endif}}
     {{if 'CUlaunchAttributeValue' in found_types}}
     if objType == CUlaunchAttributeValue:
-        return sizeof(ccuda.CUlaunchAttributeValue){{endif}}
+        return sizeof(cydriver.CUlaunchAttributeValue){{endif}}
+    {{if 'struct CUlaunchAttribute_st' in found_types}}
+    if objType == CUlaunchAttribute_st:
+        return sizeof(cydriver.CUlaunchAttribute_st){{endif}}
     {{if 'CUlaunchAttribute' in found_types}}
     if objType == CUlaunchAttribute:
-        return sizeof(ccuda.CUlaunchAttribute){{endif}}
+        return sizeof(cydriver.CUlaunchAttribute){{endif}}
+    {{if 'struct CUlaunchConfig_st' in found_types}}
+    if objType == CUlaunchConfig_st:
+        return sizeof(cydriver.CUlaunchConfig_st){{endif}}
     {{if 'CUlaunchConfig' in found_types}}
     if objType == CUlaunchConfig:
-        return sizeof(ccuda.CUlaunchConfig){{endif}}
+        return sizeof(cydriver.CUlaunchConfig){{endif}}
     {{if 'CUkernelNodeAttrValue_v1' in found_types}}
     if objType == CUkernelNodeAttrValue_v1:
-        return sizeof(ccuda.CUkernelNodeAttrValue_v1){{endif}}
+        return sizeof(cydriver.CUkernelNodeAttrValue_v1){{endif}}
     {{if 'CUkernelNodeAttrValue' in found_types}}
     if objType == CUkernelNodeAttrValue:
-        return sizeof(ccuda.CUkernelNodeAttrValue){{endif}}
+        return sizeof(cydriver.CUkernelNodeAttrValue){{endif}}
     {{if 'CUstreamAttrValue_v1' in found_types}}
     if objType == CUstreamAttrValue_v1:
-        return sizeof(ccuda.CUstreamAttrValue_v1){{endif}}
+        return sizeof(cydriver.CUstreamAttrValue_v1){{endif}}
     {{if 'CUstreamAttrValue' in found_types}}
     if objType == CUstreamAttrValue:
-        return sizeof(ccuda.CUstreamAttrValue){{endif}}
+        return sizeof(cydriver.CUstreamAttrValue){{endif}}
+    {{if 'struct CUexecAffinitySmCount_st' in found_types}}
+    if objType == CUexecAffinitySmCount_st:
+        return sizeof(cydriver.CUexecAffinitySmCount_st){{endif}}
     {{if 'CUexecAffinitySmCount_v1' in found_types}}
     if objType == CUexecAffinitySmCount_v1:
-        return sizeof(ccuda.CUexecAffinitySmCount_v1){{endif}}
+        return sizeof(cydriver.CUexecAffinitySmCount_v1){{endif}}
     {{if 'CUexecAffinitySmCount' in found_types}}
     if objType == CUexecAffinitySmCount:
-        return sizeof(ccuda.CUexecAffinitySmCount){{endif}}
+        return sizeof(cydriver.CUexecAffinitySmCount){{endif}}
+    {{if 'struct CUexecAffinityParam_st' in found_types}}
+    if objType == CUexecAffinityParam_st:
+        return sizeof(cydriver.CUexecAffinityParam_st){{endif}}
     {{if 'CUexecAffinityParam_v1' in found_types}}
     if objType == CUexecAffinityParam_v1:
-        return sizeof(ccuda.CUexecAffinityParam_v1){{endif}}
+        return sizeof(cydriver.CUexecAffinityParam_v1){{endif}}
     {{if 'CUexecAffinityParam' in found_types}}
     if objType == CUexecAffinityParam:
-        return sizeof(ccuda.CUexecAffinityParam){{endif}}
+        return sizeof(cydriver.CUexecAffinityParam){{endif}}
+    {{if 'CUstreamCallback' in found_types}}
+    if objType == CUstreamCallback:
+        return sizeof(cydriver.CUstreamCallback){{endif}}
+    {{if 'CUoccupancyB2DSize' in found_types}}
+    if objType == CUoccupancyB2DSize:
+        return sizeof(cydriver.CUoccupancyB2DSize){{endif}}
+    {{if 'struct CUDA_MEMCPY2D_st' in found_types}}
+    if objType == CUDA_MEMCPY2D_st:
+        return sizeof(cydriver.CUDA_MEMCPY2D_st){{endif}}
     {{if 'CUDA_MEMCPY2D_v2' in found_types}}
     if objType == CUDA_MEMCPY2D_v2:
-        return sizeof(ccuda.CUDA_MEMCPY2D_v2){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY2D_v2){{endif}}
     {{if 'CUDA_MEMCPY2D' in found_types}}
     if objType == CUDA_MEMCPY2D:
-        return sizeof(ccuda.CUDA_MEMCPY2D){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY2D){{endif}}
+    {{if 'struct CUDA_MEMCPY3D_st' in found_types}}
+    if objType == CUDA_MEMCPY3D_st:
+        return sizeof(cydriver.CUDA_MEMCPY3D_st){{endif}}
     {{if 'CUDA_MEMCPY3D_v2' in found_types}}
     if objType == CUDA_MEMCPY3D_v2:
-        return sizeof(ccuda.CUDA_MEMCPY3D_v2){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY3D_v2){{endif}}
     {{if 'CUDA_MEMCPY3D' in found_types}}
     if objType == CUDA_MEMCPY3D:
-        return sizeof(ccuda.CUDA_MEMCPY3D){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY3D){{endif}}
+    {{if 'struct CUDA_MEMCPY3D_PEER_st' in found_types}}
+    if objType == CUDA_MEMCPY3D_PEER_st:
+        return sizeof(cydriver.CUDA_MEMCPY3D_PEER_st){{endif}}
     {{if 'CUDA_MEMCPY3D_PEER_v1' in found_types}}
     if objType == CUDA_MEMCPY3D_PEER_v1:
-        return sizeof(ccuda.CUDA_MEMCPY3D_PEER_v1){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY3D_PEER_v1){{endif}}
     {{if 'CUDA_MEMCPY3D_PEER' in found_types}}
     if objType == CUDA_MEMCPY3D_PEER:
-        return sizeof(ccuda.CUDA_MEMCPY3D_PEER){{endif}}
+        return sizeof(cydriver.CUDA_MEMCPY3D_PEER){{endif}}
+    {{if 'struct CUDA_ARRAY_DESCRIPTOR_st' in found_types}}
+    if objType == CUDA_ARRAY_DESCRIPTOR_st:
+        return sizeof(cydriver.CUDA_ARRAY_DESCRIPTOR_st){{endif}}
     {{if 'CUDA_ARRAY_DESCRIPTOR_v2' in found_types}}
     if objType == CUDA_ARRAY_DESCRIPTOR_v2:
-        return sizeof(ccuda.CUDA_ARRAY_DESCRIPTOR_v2){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_DESCRIPTOR_v2){{endif}}
     {{if 'CUDA_ARRAY_DESCRIPTOR' in found_types}}
     if objType == CUDA_ARRAY_DESCRIPTOR:
-        return sizeof(ccuda.CUDA_ARRAY_DESCRIPTOR){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_DESCRIPTOR){{endif}}
+    {{if 'struct CUDA_ARRAY3D_DESCRIPTOR_st' in found_types}}
+    if objType == CUDA_ARRAY3D_DESCRIPTOR_st:
+        return sizeof(cydriver.CUDA_ARRAY3D_DESCRIPTOR_st){{endif}}
     {{if 'CUDA_ARRAY3D_DESCRIPTOR_v2' in found_types}}
     if objType == CUDA_ARRAY3D_DESCRIPTOR_v2:
-        return sizeof(ccuda.CUDA_ARRAY3D_DESCRIPTOR_v2){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY3D_DESCRIPTOR_v2){{endif}}
     {{if 'CUDA_ARRAY3D_DESCRIPTOR' in found_types}}
     if objType == CUDA_ARRAY3D_DESCRIPTOR:
-        return sizeof(ccuda.CUDA_ARRAY3D_DESCRIPTOR){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY3D_DESCRIPTOR){{endif}}
+    {{if 'struct CUDA_ARRAY_SPARSE_PROPERTIES_st' in found_types}}
+    if objType == CUDA_ARRAY_SPARSE_PROPERTIES_st:
+        return sizeof(cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_st){{endif}}
     {{if 'CUDA_ARRAY_SPARSE_PROPERTIES_v1' in found_types}}
     if objType == CUDA_ARRAY_SPARSE_PROPERTIES_v1:
-        return sizeof(ccuda.CUDA_ARRAY_SPARSE_PROPERTIES_v1){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_SPARSE_PROPERTIES_v1){{endif}}
     {{if 'CUDA_ARRAY_SPARSE_PROPERTIES' in found_types}}
     if objType == CUDA_ARRAY_SPARSE_PROPERTIES:
-        return sizeof(ccuda.CUDA_ARRAY_SPARSE_PROPERTIES){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_SPARSE_PROPERTIES){{endif}}
+    {{if 'struct CUDA_ARRAY_MEMORY_REQUIREMENTS_st' in found_types}}
+    if objType == CUDA_ARRAY_MEMORY_REQUIREMENTS_st:
+        return sizeof(cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS_st){{endif}}
     {{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS_v1' in found_types}}
     if objType == CUDA_ARRAY_MEMORY_REQUIREMENTS_v1:
-        return sizeof(ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_v1){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS_v1){{endif}}
     {{if 'CUDA_ARRAY_MEMORY_REQUIREMENTS' in found_types}}
     if objType == CUDA_ARRAY_MEMORY_REQUIREMENTS:
-        return sizeof(ccuda.CUDA_ARRAY_MEMORY_REQUIREMENTS){{endif}}
+        return sizeof(cydriver.CUDA_ARRAY_MEMORY_REQUIREMENTS){{endif}}
+    {{if 'struct CUDA_RESOURCE_DESC_st' in found_types}}
+    if objType == CUDA_RESOURCE_DESC_st:
+        return sizeof(cydriver.CUDA_RESOURCE_DESC_st){{endif}}
     {{if 'CUDA_RESOURCE_DESC_v1' in found_types}}
     if objType == CUDA_RESOURCE_DESC_v1:
-        return sizeof(ccuda.CUDA_RESOURCE_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_RESOURCE_DESC_v1){{endif}}
     {{if 'CUDA_RESOURCE_DESC' in found_types}}
     if objType == CUDA_RESOURCE_DESC:
-        return sizeof(ccuda.CUDA_RESOURCE_DESC){{endif}}
+        return sizeof(cydriver.CUDA_RESOURCE_DESC){{endif}}
+    {{if 'struct CUDA_TEXTURE_DESC_st' in found_types}}
+    if objType == CUDA_TEXTURE_DESC_st:
+        return sizeof(cydriver.CUDA_TEXTURE_DESC_st){{endif}}
     {{if 'CUDA_TEXTURE_DESC_v1' in found_types}}
     if objType == CUDA_TEXTURE_DESC_v1:
-        return sizeof(ccuda.CUDA_TEXTURE_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_TEXTURE_DESC_v1){{endif}}
     {{if 'CUDA_TEXTURE_DESC' in found_types}}
     if objType == CUDA_TEXTURE_DESC:
-        return sizeof(ccuda.CUDA_TEXTURE_DESC){{endif}}
+        return sizeof(cydriver.CUDA_TEXTURE_DESC){{endif}}
+    {{if 'struct CUDA_RESOURCE_VIEW_DESC_st' in found_types}}
+    if objType == CUDA_RESOURCE_VIEW_DESC_st:
+        return sizeof(cydriver.CUDA_RESOURCE_VIEW_DESC_st){{endif}}
     {{if 'CUDA_RESOURCE_VIEW_DESC_v1' in found_types}}
     if objType == CUDA_RESOURCE_VIEW_DESC_v1:
-        return sizeof(ccuda.CUDA_RESOURCE_VIEW_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_RESOURCE_VIEW_DESC_v1){{endif}}
     {{if 'CUDA_RESOURCE_VIEW_DESC' in found_types}}
     if objType == CUDA_RESOURCE_VIEW_DESC:
-        return sizeof(ccuda.CUDA_RESOURCE_VIEW_DESC){{endif}}
+        return sizeof(cydriver.CUDA_RESOURCE_VIEW_DESC){{endif}}
+    {{if 'struct CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st' in found_types}}
+    if objType == CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st:
+        return sizeof(cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st){{endif}}
     {{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1' in found_types}}
     if objType == CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1:
-        return sizeof(ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1){{endif}}
+        return sizeof(cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1){{endif}}
     {{if 'CUDA_POINTER_ATTRIBUTE_P2P_TOKENS' in found_types}}
     if objType == CUDA_POINTER_ATTRIBUTE_P2P_TOKENS:
-        return sizeof(ccuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS){{endif}}
+        return sizeof(cydriver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS){{endif}}
+    {{if 'struct CUDA_LAUNCH_PARAMS_st' in found_types}}
+    if objType == CUDA_LAUNCH_PARAMS_st:
+        return sizeof(cydriver.CUDA_LAUNCH_PARAMS_st){{endif}}
     {{if 'CUDA_LAUNCH_PARAMS_v1' in found_types}}
     if objType == CUDA_LAUNCH_PARAMS_v1:
-        return sizeof(ccuda.CUDA_LAUNCH_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_LAUNCH_PARAMS_v1){{endif}}
     {{if 'CUDA_LAUNCH_PARAMS' in found_types}}
     if objType == CUDA_LAUNCH_PARAMS:
-        return sizeof(ccuda.CUDA_LAUNCH_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_LAUNCH_PARAMS){{endif}}
+    {{if 'struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st' in found_types}}
+    if objType == CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_HANDLE_DESC' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_HANDLE_DESC:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC){{endif}}
+    {{if 'struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st' in found_types}}
+    if objType == CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_BUFFER_DESC' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_BUFFER_DESC:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC){{endif}}
+    {{if 'struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st' in found_types}}
+    if objType == CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1){{endif}}
     {{if 'CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC' in found_types}}
     if objType == CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC:
-        return sizeof(ccuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC){{endif}}
+    {{if 'struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st' in found_types}}
+    if objType == CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC){{endif}}
+    {{if 'struct CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st' in found_types}}
+    if objType == CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS){{endif}}
+    {{if 'struct CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st' in found_types}}
+    if objType == CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st:
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1){{endif}}
     {{if 'CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS' in found_types}}
     if objType == CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS:
-        return sizeof(ccuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS){{endif}}
+    {{if 'struct CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1' in found_types}}
     if objType == CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1:
-        return sizeof(ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1){{endif}}
     {{if 'CUDA_EXT_SEM_SIGNAL_NODE_PARAMS' in found_types}}
     if objType == CUDA_EXT_SEM_SIGNAL_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS){{endif}}
+    {{if 'struct CUDA_EXT_SEM_WAIT_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_EXT_SEM_WAIT_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1' in found_types}}
     if objType == CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1:
-        return sizeof(ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1){{endif}}
+        return sizeof(cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1){{endif}}
     {{if 'CUDA_EXT_SEM_WAIT_NODE_PARAMS' in found_types}}
     if objType == CUDA_EXT_SEM_WAIT_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS){{endif}}
+        return sizeof(cydriver.CUDA_EXT_SEM_WAIT_NODE_PARAMS){{endif}}
+    {{if 'CUmemGenericAllocationHandle_v1' in found_types}}
+    if objType == CUmemGenericAllocationHandle_v1:
+        return sizeof(cydriver.CUmemGenericAllocationHandle_v1){{endif}}
+    {{if 'CUmemGenericAllocationHandle' in found_types}}
+    if objType == CUmemGenericAllocationHandle:
+        return sizeof(cydriver.CUmemGenericAllocationHandle){{endif}}
+    {{if 'struct CUarrayMapInfo_st' in found_types}}
+    if objType == CUarrayMapInfo_st:
+        return sizeof(cydriver.CUarrayMapInfo_st){{endif}}
     {{if 'CUarrayMapInfo_v1' in found_types}}
     if objType == CUarrayMapInfo_v1:
-        return sizeof(ccuda.CUarrayMapInfo_v1){{endif}}
+        return sizeof(cydriver.CUarrayMapInfo_v1){{endif}}
     {{if 'CUarrayMapInfo' in found_types}}
     if objType == CUarrayMapInfo:
-        return sizeof(ccuda.CUarrayMapInfo){{endif}}
+        return sizeof(cydriver.CUarrayMapInfo){{endif}}
+    {{if 'struct CUmemLocation_st' in found_types}}
+    if objType == CUmemLocation_st:
+        return sizeof(cydriver.CUmemLocation_st){{endif}}
     {{if 'CUmemLocation_v1' in found_types}}
     if objType == CUmemLocation_v1:
-        return sizeof(ccuda.CUmemLocation_v1){{endif}}
+        return sizeof(cydriver.CUmemLocation_v1){{endif}}
     {{if 'CUmemLocation' in found_types}}
     if objType == CUmemLocation:
-        return sizeof(ccuda.CUmemLocation){{endif}}
+        return sizeof(cydriver.CUmemLocation){{endif}}
+    {{if 'struct CUmemAllocationProp_st' in found_types}}
+    if objType == CUmemAllocationProp_st:
+        return sizeof(cydriver.CUmemAllocationProp_st){{endif}}
     {{if 'CUmemAllocationProp_v1' in found_types}}
     if objType == CUmemAllocationProp_v1:
-        return sizeof(ccuda.CUmemAllocationProp_v1){{endif}}
+        return sizeof(cydriver.CUmemAllocationProp_v1){{endif}}
     {{if 'CUmemAllocationProp' in found_types}}
     if objType == CUmemAllocationProp:
-        return sizeof(ccuda.CUmemAllocationProp){{endif}}
+        return sizeof(cydriver.CUmemAllocationProp){{endif}}
+    {{if 'struct CUmemAccessDesc_st' in found_types}}
+    if objType == CUmemAccessDesc_st:
+        return sizeof(cydriver.CUmemAccessDesc_st){{endif}}
     {{if 'CUmemAccessDesc_v1' in found_types}}
     if objType == CUmemAccessDesc_v1:
-        return sizeof(ccuda.CUmemAccessDesc_v1){{endif}}
+        return sizeof(cydriver.CUmemAccessDesc_v1){{endif}}
     {{if 'CUmemAccessDesc' in found_types}}
     if objType == CUmemAccessDesc:
-        return sizeof(ccuda.CUmemAccessDesc){{endif}}
+        return sizeof(cydriver.CUmemAccessDesc){{endif}}
+    {{if 'struct CUmemPoolProps_st' in found_types}}
+    if objType == CUmemPoolProps_st:
+        return sizeof(cydriver.CUmemPoolProps_st){{endif}}
     {{if 'CUmemPoolProps_v1' in found_types}}
     if objType == CUmemPoolProps_v1:
-        return sizeof(ccuda.CUmemPoolProps_v1){{endif}}
+        return sizeof(cydriver.CUmemPoolProps_v1){{endif}}
     {{if 'CUmemPoolProps' in found_types}}
     if objType == CUmemPoolProps:
-        return sizeof(ccuda.CUmemPoolProps){{endif}}
+        return sizeof(cydriver.CUmemPoolProps){{endif}}
+    {{if 'struct CUmemPoolPtrExportData_st' in found_types}}
+    if objType == CUmemPoolPtrExportData_st:
+        return sizeof(cydriver.CUmemPoolPtrExportData_st){{endif}}
     {{if 'CUmemPoolPtrExportData_v1' in found_types}}
     if objType == CUmemPoolPtrExportData_v1:
-        return sizeof(ccuda.CUmemPoolPtrExportData_v1){{endif}}
+        return sizeof(cydriver.CUmemPoolPtrExportData_v1){{endif}}
     {{if 'CUmemPoolPtrExportData' in found_types}}
     if objType == CUmemPoolPtrExportData:
-        return sizeof(ccuda.CUmemPoolPtrExportData){{endif}}
+        return sizeof(cydriver.CUmemPoolPtrExportData){{endif}}
+    {{if 'struct CUDA_MEM_ALLOC_NODE_PARAMS_st' in found_types}}
+    if objType == CUDA_MEM_ALLOC_NODE_PARAMS_st:
+        return sizeof(cydriver.CUDA_MEM_ALLOC_NODE_PARAMS_st){{endif}}
     {{if 'CUDA_MEM_ALLOC_NODE_PARAMS' in found_types}}
     if objType == CUDA_MEM_ALLOC_NODE_PARAMS:
-        return sizeof(ccuda.CUDA_MEM_ALLOC_NODE_PARAMS){{endif}}
-    {{if True or 'CUeglFrame_v1' in found_types}}
+        return sizeof(cydriver.CUDA_MEM_ALLOC_NODE_PARAMS){{endif}}
+    {{if True}}
+    if objType == CUeglFrame_st:
+        return sizeof(cydriver.CUeglFrame_st){{endif}}
+    {{if True}}
     if objType == CUeglFrame_v1:
-        return sizeof(ccuda.CUeglFrame_v1){{endif}}
-    {{if True or 'CUeglFrame' in found_types}}
+        return sizeof(cydriver.CUeglFrame_v1){{endif}}
+    {{if True}}
     if objType == CUeglFrame:
-        return sizeof(ccuda.CUeglFrame){{endif}}
-    {{if 'cuuint32_t' in found_types}}
-    if objType == cuuint32_t:
-        return sizeof(ccuda.cuuint32_t){{endif}}
-    {{if 'cuuint64_t' in found_types}}
-    if objType == cuuint64_t:
-        return sizeof(ccuda.cuuint64_t){{endif}}
-    {{if 'CUdeviceptr_v2' in found_types}}
-    if objType == CUdeviceptr_v2:
-        return sizeof(ccuda.CUdeviceptr_v2){{endif}}
-    {{if 'CUdeviceptr' in found_types}}
-    if objType == CUdeviceptr:
-        return sizeof(ccuda.CUdeviceptr){{endif}}
-    {{if 'CUdevice_v1' in found_types}}
-    if objType == CUdevice_v1:
-        return sizeof(ccuda.CUdevice_v1){{endif}}
-    {{if 'CUdevice' in found_types}}
-    if objType == CUdevice:
-        return sizeof(ccuda.CUdevice){{endif}}
-    {{if 'CUtexObject_v1' in found_types}}
-    if objType == CUtexObject_v1:
-        return sizeof(ccuda.CUtexObject_v1){{endif}}
-    {{if 'CUtexObject' in found_types}}
-    if objType == CUtexObject:
-        return sizeof(ccuda.CUtexObject){{endif}}
-    {{if 'CUsurfObject_v1' in found_types}}
-    if objType == CUsurfObject_v1:
-        return sizeof(ccuda.CUsurfObject_v1){{endif}}
-    {{if 'CUsurfObject' in found_types}}
-    if objType == CUsurfObject:
-        return sizeof(ccuda.CUsurfObject){{endif}}
-    {{if 'CUmemGenericAllocationHandle_v1' in found_types}}
-    if objType == CUmemGenericAllocationHandle_v1:
-        return sizeof(ccuda.CUmemGenericAllocationHandle_v1){{endif}}
-    {{if 'CUmemGenericAllocationHandle' in found_types}}
-    if objType == CUmemGenericAllocationHandle:
-        return sizeof(ccuda.CUmemGenericAllocationHandle){{endif}}
-    {{if True or 'GLenum' in found_types}}
+        return sizeof(cydriver.CUeglFrame){{endif}}
+    {{if True}}
+    if objType == CUeglStreamConnection:
+        return sizeof(cydriver.CUeglStreamConnection){{endif}}
+    {{if True}}
     if objType == GLenum:
-        return sizeof(ccuda.GLenum){{endif}}
-    {{if True or 'GLuint' in found_types}}
+        return sizeof(cydriver.GLenum){{endif}}
+    {{if True}}
     if objType == GLuint:
-        return sizeof(ccuda.GLuint){{endif}}
-    {{if True or 'EGLint' in found_types}}
+        return sizeof(cydriver.GLuint){{endif}}
+    {{if True}}
+    if objType == EGLImageKHR:
+        return sizeof(cydriver.EGLImageKHR){{endif}}
+    {{if True}}
+    if objType == EGLStreamKHR:
+        return sizeof(cydriver.EGLStreamKHR){{endif}}
+    {{if True}}
     if objType == EGLint:
-        return sizeof(ccuda.EGLint){{endif}}
-    {{if True or 'VdpDevice' in found_types}}
+        return sizeof(cydriver.EGLint){{endif}}
+    {{if True}}
+    if objType == EGLSyncKHR:
+        return sizeof(cydriver.EGLSyncKHR){{endif}}
+    {{if True}}
     if objType == VdpDevice:
-        return sizeof(ccuda.VdpDevice){{endif}}
-    {{if True or 'VdpGetProcAddress' in found_types}}
+        return sizeof(cydriver.VdpDevice){{endif}}
+    {{if True}}
     if objType == VdpGetProcAddress:
-        return sizeof(ccuda.VdpGetProcAddress){{endif}}
-    {{if True or 'VdpVideoSurface' in found_types}}
+        return sizeof(cydriver.VdpGetProcAddress){{endif}}
+    {{if True}}
     if objType == VdpVideoSurface:
-        return sizeof(ccuda.VdpVideoSurface){{endif}}
-    {{if True or 'VdpOutputSurface' in found_types}}
+        return sizeof(cydriver.VdpVideoSurface){{endif}}
+    {{if True}}
     if objType == VdpOutputSurface:
-        return sizeof(ccuda.VdpOutputSurface){{endif}}
+        return sizeof(cydriver.VdpOutputSurface){{endif}}
     raise TypeError("Unknown type: " + str(objType))
diff --git a/examples/0_Introduction/clock_nvrtc_test.py b/cuda/cuda/bindings/examples/0_Introduction/clock_nvrtc_test.py
similarity index 95%
rename from examples/0_Introduction/clock_nvrtc_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/clock_nvrtc_test.py
index 2f01faee..cbfe4d21 100644
--- a/examples/0_Introduction/clock_nvrtc_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/clock_nvrtc_test.py
@@ -7,8 +7,8 @@
 # is strictly prohibited.
 import numpy as np
 from cuda import cuda
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
 
 clock_nvrtc = '''\
 extern "C" __global__  void timedReduction(const float *hinput, float *output, clock_t *timer)
diff --git a/examples/0_Introduction/simpleCubemapTexture_test.py b/cuda/cuda/bindings/examples/0_Introduction/simpleCubemapTexture_test.py
similarity index 98%
rename from examples/0_Introduction/simpleCubemapTexture_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/simpleCubemapTexture_test.py
index 2e0a9ce5..19d658fb 100644
--- a/examples/0_Introduction/simpleCubemapTexture_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/simpleCubemapTexture_test.py
@@ -11,8 +11,8 @@
 import sys
 import time
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
 
 simpleCubemapTexture = '''\
 extern "C"
diff --git a/examples/0_Introduction/simpleP2P_test.py b/cuda/cuda/bindings/examples/0_Introduction/simpleP2P_test.py
similarity index 98%
rename from examples/0_Introduction/simpleP2P_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/simpleP2P_test.py
index 1791f39d..762d4f80 100644
--- a/examples/0_Introduction/simpleP2P_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/simpleP2P_test.py
@@ -9,8 +9,8 @@
 import numpy as np
 import sys
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors
 
 simplep2p = '''\
 extern "C"
diff --git a/examples/0_Introduction/simpleZeroCopy_test.py b/cuda/cuda/bindings/examples/0_Introduction/simpleZeroCopy_test.py
similarity index 96%
rename from examples/0_Introduction/simpleZeroCopy_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/simpleZeroCopy_test.py
index 0b6dc07c..255e0a60 100644
--- a/examples/0_Introduction/simpleZeroCopy_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/simpleZeroCopy_test.py
@@ -11,9 +11,9 @@
 import random as rnd
 import sys
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors
-from examples.common.helper_string import checkCmdLineFlag
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors
+from cuda.bindings.examples.common.helper_string import checkCmdLineFlag
 
 simpleZeroCopy = '''\
 extern "C"
diff --git a/examples/0_Introduction/systemWideAtomics_test.py b/cuda/cuda/bindings/examples/0_Introduction/systemWideAtomics_test.py
similarity index 97%
rename from examples/0_Introduction/systemWideAtomics_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/systemWideAtomics_test.py
index eba44ff9..abca7bbe 100644
--- a/examples/0_Introduction/systemWideAtomics_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/systemWideAtomics_test.py
@@ -10,8 +10,8 @@
 import sys
 import os
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
 
 systemWideAtomics =  '''\
 #define LOOP_NUM 50
diff --git a/examples/0_Introduction/vectorAddDrv_test.py b/cuda/cuda/bindings/examples/0_Introduction/vectorAddDrv_test.py
similarity index 96%
rename from examples/0_Introduction/vectorAddDrv_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/vectorAddDrv_test.py
index 5bc64a61..2f970182 100644
--- a/examples/0_Introduction/vectorAddDrv_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/vectorAddDrv_test.py
@@ -9,8 +9,8 @@
 import math
 import numpy as np
 from cuda import cuda
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDeviceDRV
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDeviceDRV
 
 vectorAddDrv = '''\
 /* Vector addition: C = A + B.
diff --git a/examples/0_Introduction/vectorAddMMAP_test.py b/cuda/cuda/bindings/examples/0_Introduction/vectorAddMMAP_test.py
similarity index 98%
rename from examples/0_Introduction/vectorAddMMAP_test.py
rename to cuda/cuda/bindings/examples/0_Introduction/vectorAddMMAP_test.py
index 9a6a41ce..82b7b429 100644
--- a/examples/0_Introduction/vectorAddMMAP_test.py
+++ b/cuda/cuda/bindings/examples/0_Introduction/vectorAddMMAP_test.py
@@ -10,8 +10,8 @@
 import numpy as np
 import sys
 from cuda import cuda
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDeviceDRV
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDeviceDRV
 
 vectorAddMMAP = '''\
 /* Vector addition: C = A + B.
@@ -82,7 +82,7 @@ def simpleMallocMultiDeviceMmap(size, residentDevices, mappingDevices, align = 0
 
     # Get the minimum granularity needed for the accessing devices
     # (the max of the minimum granularity of each participating device)
-    for device in residentDevices:
+    for device in mappingDevices:
         prop.location.id = device
         status, granularity = cuda.cuMemGetAllocationGranularity(prop, cuda.CUmemAllocationGranularity_flags.CU_MEM_ALLOC_GRANULARITY_MINIMUM)
         if status != cuda.CUresult.CUDA_SUCCESS:
diff --git a/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py b/cuda/cuda/bindings/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py
similarity index 97%
rename from examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py
rename to cuda/cuda/bindings/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py
index a116ecba..37cf1573 100644
--- a/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py
+++ b/cuda/cuda/bindings/examples/2_Concepts_and_Techniques/streamOrderedAllocation_test.py
@@ -11,9 +11,9 @@
 import random as rnd
 import sys
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
-from examples.common.helper_string import checkCmdLineFlag
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common.helper_string import checkCmdLineFlag
 
 streamOrderedAllocation = '''\
 /* Add two vectors on the GPU */
diff --git a/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py b/cuda/cuda/bindings/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py
similarity index 99%
rename from examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py
rename to cuda/cuda/bindings/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py
index a308c7c9..823fbe5f 100644
--- a/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py
+++ b/cuda/cuda/bindings/examples/3_CUDA_Features/globalToShmemAsyncCopy_test.py
@@ -12,9 +12,9 @@
 import pytest
 from cuda import cuda, cudart
 from enum import Enum
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
-from examples.common.helper_string import checkCmdLineFlag, getCmdLineArgumentInt
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common.helper_string import checkCmdLineFlag, getCmdLineArgumentInt
 
 blockSize = 16
 class kernels(Enum):
diff --git a/examples/3_CUDA_Features/simpleCudaGraphs_test.py b/cuda/cuda/bindings/examples/3_CUDA_Features/simpleCudaGraphs_test.py
similarity index 99%
rename from examples/3_CUDA_Features/simpleCudaGraphs_test.py
rename to cuda/cuda/bindings/examples/3_CUDA_Features/simpleCudaGraphs_test.py
index 2c60ddee..f843ba9d 100644
--- a/examples/3_CUDA_Features/simpleCudaGraphs_test.py
+++ b/cuda/cuda/bindings/examples/3_CUDA_Features/simpleCudaGraphs_test.py
@@ -9,8 +9,8 @@
 import numpy as np
 import random as rnd
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
 
 THREADS_PER_BLOCK = 512
 GRAPH_LAUNCH_ITERATIONS = 3
diff --git a/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py b/cuda/cuda/bindings/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py
similarity index 98%
rename from examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py
rename to cuda/cuda/bindings/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py
index 2e0d7252..80ff0254 100644
--- a/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py
+++ b/cuda/cuda/bindings/examples/4_CUDA_Libraries/conjugateGradientMultiBlockCG_test.py
@@ -10,8 +10,8 @@
 import numpy as np
 import sys
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors, findCudaDevice
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors, findCudaDevice
 from random import random
 
 conjugateGradientMultiBlockCG = '''\
diff --git a/examples/__init__.py b/cuda/cuda/bindings/examples/__init__.py
similarity index 100%
rename from examples/__init__.py
rename to cuda/cuda/bindings/examples/__init__.py
diff --git a/examples/common/common.py b/cuda/cuda/bindings/examples/common/common.py
similarity index 97%
rename from examples/common/common.py
rename to cuda/cuda/bindings/examples/common/common.py
index 8a498369..663ead99 100644
--- a/examples/common/common.py
+++ b/cuda/cuda/bindings/examples/common/common.py
@@ -9,7 +9,7 @@
 import numpy as np
 import os
 from cuda import cuda, cudart, nvrtc
-from examples.common.helper_cuda import checkCudaErrors
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors
 
 class KernelHelper:
     def __init__(self, code, devID):
diff --git a/examples/common/helper_cuda.py b/cuda/cuda/bindings/examples/common/helper_cuda.py
similarity index 94%
rename from examples/common/helper_cuda.py
rename to cuda/cuda/bindings/examples/common/helper_cuda.py
index 7d7e5181..75043ff1 100644
--- a/examples/common/helper_cuda.py
+++ b/cuda/cuda/bindings/examples/common/helper_cuda.py
@@ -6,7 +6,7 @@
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
 from cuda import cuda, cudart, nvrtc
-from examples.common.helper_string import getCmdLineArgumentInt, checkCmdLineFlag
+from cuda.bindings.examples.common.helper_string import getCmdLineArgumentInt, checkCmdLineFlag
 
 def _cudaGetErrorEnum(error):
     if isinstance(error, cuda.CUresult):
diff --git a/examples/common/helper_string.py b/cuda/cuda/bindings/examples/common/helper_string.py
similarity index 100%
rename from examples/common/helper_string.py
rename to cuda/cuda/bindings/examples/common/helper_string.py
diff --git a/examples/extra/isoFDModelling_test.py b/cuda/cuda/bindings/examples/extra/isoFDModelling_test.py
similarity index 99%
rename from examples/extra/isoFDModelling_test.py
rename to cuda/cuda/bindings/examples/extra/isoFDModelling_test.py
index 63e2061a..50277f94 100644
--- a/examples/extra/isoFDModelling_test.py
+++ b/cuda/cuda/bindings/examples/extra/isoFDModelling_test.py
@@ -8,8 +8,8 @@
 import numpy as np
 import time
 from cuda import cuda, cudart
-from examples.common import common
-from examples.common.helper_cuda import checkCudaErrors
+from cuda.bindings.examples.common import common
+from cuda.bindings.examples.common.helper_cuda import checkCudaErrors
 
 isoPropagator = '''\
 extern "C"
diff --git a/examples/extra/jit_program_test.py b/cuda/cuda/bindings/examples/extra/jit_program_test.py
similarity index 100%
rename from examples/extra/jit_program_test.py
rename to cuda/cuda/bindings/examples/extra/jit_program_test.py
diff --git a/examples/extra/numba_emm_plugin.py b/cuda/cuda/bindings/examples/extra/numba_emm_plugin.py
similarity index 100%
rename from examples/extra/numba_emm_plugin.py
rename to cuda/cuda/bindings/examples/extra/numba_emm_plugin.py
diff --git a/examples/setup.cfg b/cuda/cuda/bindings/examples/setup.cfg
similarity index 100%
rename from examples/setup.cfg
rename to cuda/cuda/bindings/examples/setup.cfg
diff --git a/cuda/nvrtc.pxd.in b/cuda/cuda/bindings/nvrtc.pxd.in
similarity index 76%
rename from cuda/nvrtc.pxd.in
rename to cuda/cuda/bindings/nvrtc.pxd.in
index 3b649e19..fdd23e2f 100644
--- a/cuda/nvrtc.pxd.in
+++ b/cuda/cuda/bindings/nvrtc.pxd.in
@@ -1,12 +1,12 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda.cnvrtc as cnvrtc
-cimport cuda._lib.utils as utils
+cimport cuda.bindings.cynvrtc as cynvrtc
+cimport cuda.bindings._lib.utils as utils
 
 {{if 'nvrtcProgram' in found_types}}
 
@@ -21,6 +21,6 @@ cdef class nvrtcProgram:
         Get memory address of class instance
 
     """
-    cdef cnvrtc.nvrtcProgram  __val
-    cdef cnvrtc.nvrtcProgram* _ptr
+    cdef cynvrtc.nvrtcProgram  __val
+    cdef cynvrtc.nvrtcProgram* _ptr
 {{endif}}
diff --git a/cuda/nvrtc.pyx.in b/cuda/cuda/bindings/nvrtc.pyx.in
similarity index 74%
rename from cuda/nvrtc.pyx.in
rename to cuda/cuda/bindings/nvrtc.pyx.in
index 61093182..3a4acc4c 100644
--- a/cuda/nvrtc.pyx.in
+++ b/cuda/cuda/bindings/nvrtc.pyx.in
@@ -1,16 +1,16 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-from typing import List, Tuple, Any
+from typing import List, Tuple, Any, Optional
 from enum import IntEnum
 import cython
 import ctypes
 from libc.stdlib cimport calloc, free
-from libc.string cimport memcpy
+from libc cimport string
 from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
 from libc.stddef cimport wchar_t
 from libc.limits cimport CHAR_MIN
@@ -35,11 +35,13 @@ ctypedef unsigned long long int32_t_ptr
 ctypedef unsigned long long int64_t_ptr
 ctypedef unsigned long long unsigned_ptr
 ctypedef unsigned long long unsigned_long_long_ptr
+ctypedef unsigned long long long_long_ptr
 ctypedef unsigned long long size_t_ptr
 ctypedef unsigned long long float_ptr
 ctypedef unsigned long long double_ptr
 ctypedef unsigned long long void_ptr
 
+
 {{if 'nvrtcResult' in found_types}}
 
 class nvrtcResult(IntEnum):
@@ -48,29 +50,29 @@ class nvrtcResult(IntEnum):
     NVRTC API functions return nvrtcResult to indicate the call result.
     """
     {{if 'NVRTC_SUCCESS' in found_values}}
-    NVRTC_SUCCESS = cnvrtc.nvrtcResult.NVRTC_SUCCESS{{endif}}
+    NVRTC_SUCCESS = cynvrtc.nvrtcResult.NVRTC_SUCCESS{{endif}}
     {{if 'NVRTC_ERROR_OUT_OF_MEMORY' in found_values}}
-    NVRTC_ERROR_OUT_OF_MEMORY = cnvrtc.nvrtcResult.NVRTC_ERROR_OUT_OF_MEMORY{{endif}}
+    NVRTC_ERROR_OUT_OF_MEMORY = cynvrtc.nvrtcResult.NVRTC_ERROR_OUT_OF_MEMORY{{endif}}
     {{if 'NVRTC_ERROR_PROGRAM_CREATION_FAILURE' in found_values}}
-    NVRTC_ERROR_PROGRAM_CREATION_FAILURE = cnvrtc.nvrtcResult.NVRTC_ERROR_PROGRAM_CREATION_FAILURE{{endif}}
+    NVRTC_ERROR_PROGRAM_CREATION_FAILURE = cynvrtc.nvrtcResult.NVRTC_ERROR_PROGRAM_CREATION_FAILURE{{endif}}
     {{if 'NVRTC_ERROR_INVALID_INPUT' in found_values}}
-    NVRTC_ERROR_INVALID_INPUT = cnvrtc.nvrtcResult.NVRTC_ERROR_INVALID_INPUT{{endif}}
+    NVRTC_ERROR_INVALID_INPUT = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_INPUT{{endif}}
     {{if 'NVRTC_ERROR_INVALID_PROGRAM' in found_values}}
-    NVRTC_ERROR_INVALID_PROGRAM = cnvrtc.nvrtcResult.NVRTC_ERROR_INVALID_PROGRAM{{endif}}
+    NVRTC_ERROR_INVALID_PROGRAM = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_PROGRAM{{endif}}
     {{if 'NVRTC_ERROR_INVALID_OPTION' in found_values}}
-    NVRTC_ERROR_INVALID_OPTION = cnvrtc.nvrtcResult.NVRTC_ERROR_INVALID_OPTION{{endif}}
+    NVRTC_ERROR_INVALID_OPTION = cynvrtc.nvrtcResult.NVRTC_ERROR_INVALID_OPTION{{endif}}
     {{if 'NVRTC_ERROR_COMPILATION' in found_values}}
-    NVRTC_ERROR_COMPILATION = cnvrtc.nvrtcResult.NVRTC_ERROR_COMPILATION{{endif}}
+    NVRTC_ERROR_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_COMPILATION{{endif}}
     {{if 'NVRTC_ERROR_BUILTIN_OPERATION_FAILURE' in found_values}}
-    NVRTC_ERROR_BUILTIN_OPERATION_FAILURE = cnvrtc.nvrtcResult.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE{{endif}}
+    NVRTC_ERROR_BUILTIN_OPERATION_FAILURE = cynvrtc.nvrtcResult.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE{{endif}}
     {{if 'NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION' in found_values}}
-    NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = cnvrtc.nvrtcResult.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION{{endif}}
+    NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION{{endif}}
     {{if 'NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION' in found_values}}
-    NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = cnvrtc.nvrtcResult.NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION{{endif}}
+    NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION = cynvrtc.nvrtcResult.NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION{{endif}}
     {{if 'NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID' in found_values}}
-    NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID = cnvrtc.nvrtcResult.NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID{{endif}}
+    NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID = cynvrtc.nvrtcResult.NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID{{endif}}
     {{if 'NVRTC_ERROR_INTERNAL_ERROR' in found_values}}
-    NVRTC_ERROR_INTERNAL_ERROR = cnvrtc.nvrtcResult.NVRTC_ERROR_INTERNAL_ERROR{{endif}}
+    NVRTC_ERROR_INTERNAL_ERROR = cynvrtc.nvrtcResult.NVRTC_ERROR_INTERNAL_ERROR{{endif}}
 {{endif}}
 {{if 'nvrtcProgram' in found_types}}
 
@@ -88,9 +90,9 @@ cdef class nvrtcProgram:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <cnvrtc.nvrtcProgram>init_value
+            self._ptr[0] = <cynvrtc.nvrtcProgram>init_value
         else:
-            self._ptr = <cnvrtc.nvrtcProgram *>_ptr
+            self._ptr = <cynvrtc.nvrtcProgram *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -103,7 +105,6 @@ cdef class nvrtcProgram:
         return <void_ptr>self._ptr
 {{endif}}
 
-
 {{if 'nvrtcGetErrorString' in found_functions}}
 
 @cython.embedsignature(True)
@@ -122,8 +123,8 @@ def nvrtcGetErrorString(result not None : nvrtcResult):
     bytes
         Message string for the given :py:obj:`~.nvrtcResult` code.
     """
-    cdef cnvrtc.nvrtcResult cresult = result.value
-    err = cnvrtc.nvrtcGetErrorString(cresult)
+    cdef cynvrtc.nvrtcResult cyresult = result.value
+    err = cynvrtc.nvrtcGetErrorString(cyresult)
     return (nvrtcResult.NVRTC_SUCCESS, err)
 {{endif}}
 
@@ -145,7 +146,7 @@ def nvrtcVersion():
     """
     cdef int major = 0
     cdef int minor = 0
-    err = cnvrtc.nvrtcVersion(&major, &minor)
+    err = cynvrtc.nvrtcVersion(&major, &minor)
     return (nvrtcResult(err), major, minor)
 {{endif}}
 
@@ -166,7 +167,7 @@ def nvrtcGetNumSupportedArchs():
         number of supported architectures.
     """
     cdef int numArchs = 0
-    err = cnvrtc.nvrtcGetNumSupportedArchs(&numArchs)
+    err = cynvrtc.nvrtcGetNumSupportedArchs(&numArchs)
     return (nvrtcResult(err), numArchs)
 {{endif}}
 
@@ -189,14 +190,15 @@ def nvrtcGetSupportedArchs():
     cdef vector[int] supportedArchs
     _, s = nvrtcGetNumSupportedArchs()
     supportedArchs.resize(s)
-    err = cnvrtc.nvrtcGetSupportedArchs(supportedArchs.data())
+
+    err = cynvrtc.nvrtcGetSupportedArchs(supportedArchs.data())
     return (nvrtcResult(err), supportedArchs)
 {{endif}}
 
 {{if 'nvrtcCreateProgram' in found_functions}}
 
 @cython.embedsignature(True)
-def nvrtcCreateProgram(char* src, char* name, int numHeaders, list headers, list includeNames):
+def nvrtcCreateProgram(char* src, char* name, int numHeaders, headers : Optional[Tuple[bytes] | List[bytes]], includeNames : Optional[Tuple[bytes] | List[bytes]]):
     """ nvrtcCreateProgram creates an instance of nvrtcProgram with the given input parameters, and sets the output parameter `prog` with it.
 
     Parameters
@@ -232,12 +234,18 @@ def nvrtcCreateProgram(char* src, char* name, int numHeaders, list headers, list
     --------
     :py:obj:`~.nvrtcDestroyProgram`
     """
+    includeNames = [] if includeNames is None else includeNames
+    if not all(isinstance(_x, (bytes)) for _x in includeNames):
+        raise TypeError("Argument 'includeNames' is not instance of type (expected Tuple[bytes] or List[bytes]")
+    headers = [] if headers is None else headers
+    if not all(isinstance(_x, (bytes)) for _x in headers):
+        raise TypeError("Argument 'headers' is not instance of type (expected Tuple[bytes] or List[bytes]")
     cdef nvrtcProgram prog = nvrtcProgram()
     if numHeaders > len(headers): raise RuntimeError("List is too small: " + str(len(headers)) + " < " + str(numHeaders))
     if numHeaders > len(includeNames): raise RuntimeError("List is too small: " + str(len(includeNames)) + " < " + str(numHeaders))
-    cdef vector[const char*] cheaders = headers
-    cdef vector[const char*] cincludeNames = includeNames
-    err = cnvrtc.nvrtcCreateProgram(prog._ptr, src, name, numHeaders, cheaders.data(), cincludeNames.data())
+    cdef vector[const char*] cyheaders = headers
+    cdef vector[const char*] cyincludeNames = includeNames
+    err = cynvrtc.nvrtcCreateProgram(<cynvrtc.nvrtcProgram*>prog._ptr, src, name, numHeaders, cyheaders.data(), cyincludeNames.data())
     return (nvrtcResult(err), prog)
 {{endif}}
 
@@ -262,25 +270,24 @@ def nvrtcDestroyProgram(prog):
     --------
     :py:obj:`~.nvrtcCreateProgram`
     """
-    cdef cnvrtc.nvrtcProgram *cprog
+    cdef cynvrtc.nvrtcProgram *cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram*><void_ptr>NULL
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>NULL
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = prog.getPtr()
-        cprog = <cnvrtc.nvrtcProgram*><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>pprog
     elif isinstance(prog, (int)):
-        cprog = <cnvrtc.nvrtcProgram*><void_ptr>prog
+        cyprog = <cynvrtc.nvrtcProgram*><void_ptr>prog
     else:
         raise TypeError("Argument 'prog' is not instance of type (expected <class 'int, nvrtc.nvrtcProgram'>, found " + str(type(prog)))
-
-    err = cnvrtc.nvrtcDestroyProgram(cprog)
+    err = cynvrtc.nvrtcDestroyProgram(cyprog)
     return (nvrtcResult(err),)
 {{endif}}
 
 {{if 'nvrtcCompileProgram' in found_functions}}
 
 @cython.embedsignature(True)
-def nvrtcCompileProgram(prog, int numOptions, list options):
+def nvrtcCompileProgram(prog, int numOptions, options : Optional[Tuple[bytes] | List[bytes]]):
     """ nvrtcCompileProgram compiles the given program.
 
     It supports compile options listed in :py:obj:`~.Supported Compile
@@ -307,19 +314,21 @@ def nvrtcCompileProgram(prog, int numOptions, list options):
         - :py:obj:`~.NVRTC_ERROR_COMPILATION`
         - :py:obj:`~.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    options = [] if options is None else options
+    if not all(isinstance(_x, (bytes)) for _x in options):
+        raise TypeError("Argument 'options' is not instance of type (expected Tuple[bytes] or List[bytes]")
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     if numOptions > len(options): raise RuntimeError("List is too small: " + str(len(options)) + " < " + str(numOptions))
-    cdef vector[const char*] coptions = options
-    err = cnvrtc.nvrtcCompileProgram(cprog, numOptions, coptions.data())
+    cdef vector[const char*] cyoptions = options
+    err = cynvrtc.nvrtcCompileProgram(cyprog, numOptions, cyoptions.data())
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -347,18 +356,17 @@ def nvrtcGetPTXSize(prog):
     --------
     :py:obj:`~.nvrtcGetPTX`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t ptxSizeRet = 0
-    err = cnvrtc.nvrtcGetPTXSize(cprog, &ptxSizeRet)
+    err = cynvrtc.nvrtcGetPTXSize(cyprog, &ptxSizeRet)
     return (nvrtcResult(err), ptxSizeRet)
 {{endif}}
 
@@ -386,17 +394,16 @@ def nvrtcGetPTX(prog, char* ptx):
     --------
     :py:obj:`~.nvrtcGetPTXSize`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
-    err = cnvrtc.nvrtcGetPTX(cprog, ptx)
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    err = cynvrtc.nvrtcGetPTX(cyprog, ptx)
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -424,18 +431,17 @@ def nvrtcGetCUBINSize(prog):
     --------
     :py:obj:`~.nvrtcGetCUBIN`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t cubinSizeRet = 0
-    err = cnvrtc.nvrtcGetCUBINSize(cprog, &cubinSizeRet)
+    err = cynvrtc.nvrtcGetCUBINSize(cyprog, &cubinSizeRet)
     return (nvrtcResult(err), cubinSizeRet)
 {{endif}}
 
@@ -463,17 +469,16 @@ def nvrtcGetCUBIN(prog, char* cubin):
     --------
     :py:obj:`~.nvrtcGetCUBINSize`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
-    err = cnvrtc.nvrtcGetCUBIN(cprog, cubin)
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    err = cynvrtc.nvrtcGetCUBIN(cyprog, cubin)
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -501,18 +506,17 @@ def nvrtcGetNVVMSize(prog):
     --------
     :py:obj:`~.nvrtcGetNVVM`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t nvvmSizeRet = 0
-    err = cnvrtc.nvrtcGetNVVMSize(cprog, &nvvmSizeRet)
+    err = cynvrtc.nvrtcGetNVVMSize(cyprog, &nvvmSizeRet)
     return (nvrtcResult(err), nvvmSizeRet)
 {{endif}}
 
@@ -540,17 +544,16 @@ def nvrtcGetNVVM(prog, char* nvvm):
     --------
     :py:obj:`~.nvrtcGetNVVMSize`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
-    err = cnvrtc.nvrtcGetNVVM(cprog, nvvm)
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    err = cynvrtc.nvrtcGetNVVM(cyprog, nvvm)
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -581,18 +584,17 @@ def nvrtcGetProgramLogSize(prog):
     --------
     :py:obj:`~.nvrtcGetProgramLog`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef size_t logSizeRet = 0
-    err = cnvrtc.nvrtcGetProgramLogSize(cprog, &logSizeRet)
+    err = cynvrtc.nvrtcGetProgramLogSize(cyprog, &logSizeRet)
     return (nvrtcResult(err), logSizeRet)
 {{endif}}
 
@@ -620,17 +622,16 @@ def nvrtcGetProgramLog(prog, char* log):
     --------
     :py:obj:`~.nvrtcGetProgramLogSize`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
-    err = cnvrtc.nvrtcGetProgramLog(cprog, log)
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    err = cynvrtc.nvrtcGetProgramLog(cyprog, log)
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -661,17 +662,16 @@ def nvrtcAddNameExpression(prog, char* name_expression):
     --------
     :py:obj:`~.nvrtcGetLoweredName`
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
-    err = cnvrtc.nvrtcAddNameExpression(cprog, name_expression)
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
+    err = cynvrtc.nvrtcAddNameExpression(cyprog, name_expression)
     return (nvrtcResult(err),)
 {{endif}}
 
@@ -704,18 +704,17 @@ def nvrtcGetLoweredName(prog, char* name_expression):
     --------
     nvrtcAddNameExpression
     """
-    cdef cnvrtc.nvrtcProgram cprog
+    cdef cynvrtc.nvrtcProgram cyprog
     if prog is None:
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>0
-    elif isinstance(prog, (nvrtcProgram)):
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>0
+    elif isinstance(prog, (nvrtcProgram,)):
         pprog = int(prog)
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     else:
         pprog = int(nvrtcProgram(prog))
-        cprog = <cnvrtc.nvrtcProgram><void_ptr>pprog
-
+        cyprog = <cynvrtc.nvrtcProgram><void_ptr>pprog
     cdef const char* lowered_name = NULL
-    err = cnvrtc.nvrtcGetLoweredName(cprog, name_expression, &lowered_name)
+    err = cynvrtc.nvrtcGetLoweredName(cyprog, name_expression, &lowered_name)
     return (nvrtcResult(err), <bytes>lowered_name)
 {{endif}}
 
@@ -735,5 +734,5 @@ def sizeof(objType):
     """
     {{if 'nvrtcProgram' in found_types}}
     if objType == nvrtcProgram:
-        return sizeof(cnvrtc.nvrtcProgram){{endif}}
+        return sizeof(cynvrtc.nvrtcProgram){{endif}}
     raise TypeError("Unknown type: " + str(objType))
diff --git a/cuda/cudart.pxd.in b/cuda/cuda/bindings/runtime.pxd.in
similarity index 73%
rename from cuda/cudart.pxd.in
rename to cuda/cuda/bindings/runtime.pxd.in
index c13838cd..672e242a 100644
--- a/cuda/cudart.pxd.in
+++ b/cuda/cuda/bindings/runtime.pxd.in
@@ -1,13 +1,13 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
 # this software. Any use, reproduction, disclosure, or distribution of
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
-cimport cuda.ccudart as ccudart
-cimport cuda._lib.utils as utils
-cimport cuda.cuda as cuda
+cimport cuda.bindings.cyruntime as cyruntime
+cimport cuda.bindings._lib.utils as utils
+cimport cuda.bindings.driver as driver
 
 {{if 'cudaArray_t' in found_types}}
 
@@ -22,8 +22,8 @@ cdef class cudaArray_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaArray_t  __val
-    cdef ccudart.cudaArray_t* _ptr
+    cdef cyruntime.cudaArray_t  __val
+    cdef cyruntime.cudaArray_t* _ptr
 {{endif}}
 
 {{if 'cudaArray_const_t' in found_types}}
@@ -39,8 +39,8 @@ cdef class cudaArray_const_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaArray_const_t  __val
-    cdef ccudart.cudaArray_const_t* _ptr
+    cdef cyruntime.cudaArray_const_t  __val
+    cdef cyruntime.cudaArray_const_t* _ptr
 {{endif}}
 
 {{if 'cudaMipmappedArray_t' in found_types}}
@@ -56,8 +56,8 @@ cdef class cudaMipmappedArray_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMipmappedArray_t  __val
-    cdef ccudart.cudaMipmappedArray_t* _ptr
+    cdef cyruntime.cudaMipmappedArray_t  __val
+    cdef cyruntime.cudaMipmappedArray_t* _ptr
 {{endif}}
 
 {{if 'cudaMipmappedArray_const_t' in found_types}}
@@ -73,8 +73,8 @@ cdef class cudaMipmappedArray_const_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMipmappedArray_const_t  __val
-    cdef ccudart.cudaMipmappedArray_const_t* _ptr
+    cdef cyruntime.cudaMipmappedArray_const_t  __val
+    cdef cyruntime.cudaMipmappedArray_const_t* _ptr
 {{endif}}
 
 {{if 'cudaGraphicsResource_t' in found_types}}
@@ -90,8 +90,8 @@ cdef class cudaGraphicsResource_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaGraphicsResource_t  __val
-    cdef ccudart.cudaGraphicsResource_t* _ptr
+    cdef cyruntime.cudaGraphicsResource_t  __val
+    cdef cyruntime.cudaGraphicsResource_t* _ptr
 {{endif}}
 
 {{if 'cudaExternalMemory_t' in found_types}}
@@ -107,8 +107,8 @@ cdef class cudaExternalMemory_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemory_t  __val
-    cdef ccudart.cudaExternalMemory_t* _ptr
+    cdef cyruntime.cudaExternalMemory_t  __val
+    cdef cyruntime.cudaExternalMemory_t* _ptr
 {{endif}}
 
 {{if 'cudaExternalSemaphore_t' in found_types}}
@@ -124,11 +124,11 @@ cdef class cudaExternalSemaphore_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphore_t  __val
-    cdef ccudart.cudaExternalSemaphore_t* _ptr
+    cdef cyruntime.cudaExternalSemaphore_t  __val
+    cdef cyruntime.cudaExternalSemaphore_t* _ptr
 {{endif}}
 
-{{if True or 'EGLImageKHR' in found_types}}
+{{if True}}
 
 cdef class EGLImageKHR:
     """
@@ -139,11 +139,11 @@ cdef class EGLImageKHR:
         Get memory address of class instance
 
     """
-    cdef ccudart.EGLImageKHR  __val
-    cdef ccudart.EGLImageKHR* _ptr
+    cdef cyruntime.EGLImageKHR  __val
+    cdef cyruntime.EGLImageKHR* _ptr
 {{endif}}
 
-{{if True or 'EGLStreamKHR' in found_types}}
+{{if True}}
 
 cdef class EGLStreamKHR:
     """
@@ -154,11 +154,11 @@ cdef class EGLStreamKHR:
         Get memory address of class instance
 
     """
-    cdef ccudart.EGLStreamKHR  __val
-    cdef ccudart.EGLStreamKHR* _ptr
+    cdef cyruntime.EGLStreamKHR  __val
+    cdef cyruntime.EGLStreamKHR* _ptr
 {{endif}}
 
-{{if True or 'EGLSyncKHR' in found_types}}
+{{if True}}
 
 cdef class EGLSyncKHR:
     """
@@ -169,8 +169,8 @@ cdef class EGLSyncKHR:
         Get memory address of class instance
 
     """
-    cdef ccudart.EGLSyncKHR  __val
-    cdef ccudart.EGLSyncKHR* _ptr
+    cdef cyruntime.EGLSyncKHR  __val
+    cdef cyruntime.EGLSyncKHR* _ptr
 {{endif}}
 
 {{if 'cudaHostFn_t' in found_types}}
@@ -184,8 +184,8 @@ cdef class cudaHostFn_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaHostFn_t  __val
-    cdef ccudart.cudaHostFn_t* _ptr
+    cdef cyruntime.cudaHostFn_t  __val
+    cdef cyruntime.cudaHostFn_t* _ptr
 {{endif}}
 
 {{if 'cudaStreamCallback_t' in found_types}}
@@ -199,15 +199,14 @@ cdef class cudaStreamCallback_t:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaStreamCallback_t  __val
-    cdef ccudart.cudaStreamCallback_t* _ptr
+    cdef cyruntime.cudaStreamCallback_t  __val
+    cdef cyruntime.cudaStreamCallback_t* _ptr
 {{endif}}
 
-{{if 'dim3' in found_types}}
+{{if 'struct dim3' in found_types}}
 
 cdef class dim3:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -223,10 +222,10 @@ cdef class dim3:
         Get memory address of class instance
 
     """
-    cdef ccudart.dim3  __val
-    cdef ccudart.dim3* _ptr
+    cdef cyruntime.dim3 __val
+    cdef cyruntime.dim3* _ptr
 {{endif}}
-{{if True or 'cudaChannelFormatDesc' in found_types}}
+{{if 'struct cudaChannelFormatDesc' in found_types}}
 
 cdef class cudaChannelFormatDesc:
     """
@@ -251,14 +250,13 @@ cdef class cudaChannelFormatDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaChannelFormatDesc  __val
-    cdef ccudart.cudaChannelFormatDesc* _ptr
+    cdef cyruntime.cudaChannelFormatDesc __val
+    cdef cyruntime.cudaChannelFormatDesc* _ptr
 {{endif}}
-{{if 'cudaArraySparseProperties' in found_types}}
+{{if 'struct cudaArraySparseProperties' in found_types}}
 
-cdef class _cudaArraySparseProperties_tileExtent_s:
+cdef class anon_struct0:
     """
-
     Attributes
     ----------
     width : unsigned int
@@ -274,9 +272,9 @@ cdef class _cudaArraySparseProperties_tileExtent_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaArraySparseProperties* _ptr
+    cdef cyruntime.cudaArraySparseProperties* _ptr
 {{endif}}
-{{if 'cudaArraySparseProperties' in found_types}}
+{{if 'struct cudaArraySparseProperties' in found_types}}
 
 cdef class cudaArraySparseProperties:
     """
@@ -284,7 +282,7 @@ cdef class cudaArraySparseProperties:
 
     Attributes
     ----------
-    tileExtent : _cudaArraySparseProperties_tileExtent_s
+    tileExtent : anon_struct0
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins
@@ -301,11 +299,11 @@ cdef class cudaArraySparseProperties:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaArraySparseProperties  __val
-    cdef ccudart.cudaArraySparseProperties* _ptr
-    cdef _cudaArraySparseProperties_tileExtent_s _tileExtent
+    cdef cyruntime.cudaArraySparseProperties __val
+    cdef cyruntime.cudaArraySparseProperties* _ptr
+    cdef anon_struct0 _tileExtent
 {{endif}}
-{{if 'cudaArrayMemoryRequirements' in found_types}}
+{{if 'struct cudaArrayMemoryRequirements' in found_types}}
 
 cdef class cudaArrayMemoryRequirements:
     """
@@ -326,10 +324,10 @@ cdef class cudaArrayMemoryRequirements:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaArrayMemoryRequirements  __val
-    cdef ccudart.cudaArrayMemoryRequirements* _ptr
+    cdef cyruntime.cudaArrayMemoryRequirements __val
+    cdef cyruntime.cudaArrayMemoryRequirements* _ptr
 {{endif}}
-{{if True or 'cudaPitchedPtr' in found_types}}
+{{if 'struct cudaPitchedPtr' in found_types}}
 
 cdef class cudaPitchedPtr:
     """
@@ -352,11 +350,10 @@ cdef class cudaPitchedPtr:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaPitchedPtr  __val
-    cdef ccudart.cudaPitchedPtr* _ptr
-    cdef utils.HelperInputVoidPtr _cptr
+    cdef cyruntime.cudaPitchedPtr __val
+    cdef cyruntime.cudaPitchedPtr* _ptr
 {{endif}}
-{{if 'cudaExtent' in found_types}}
+{{if 'struct cudaExtent' in found_types}}
 
 cdef class cudaExtent:
     """
@@ -378,10 +375,10 @@ cdef class cudaExtent:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExtent  __val
-    cdef ccudart.cudaExtent* _ptr
+    cdef cyruntime.cudaExtent __val
+    cdef cyruntime.cudaExtent* _ptr
 {{endif}}
-{{if 'cudaPos' in found_types}}
+{{if 'struct cudaPos' in found_types}}
 
 cdef class cudaPos:
     """
@@ -402,10 +399,10 @@ cdef class cudaPos:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaPos  __val
-    cdef ccudart.cudaPos* _ptr
+    cdef cyruntime.cudaPos __val
+    cdef cyruntime.cudaPos* _ptr
 {{endif}}
-{{if 'cudaMemcpy3DParms' in found_types}}
+{{if 'struct cudaMemcpy3DParms' in found_types}}
 
 cdef class cudaMemcpy3DParms:
     """
@@ -436,8 +433,8 @@ cdef class cudaMemcpy3DParms:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemcpy3DParms  __val
-    cdef ccudart.cudaMemcpy3DParms* _ptr
+    cdef cyruntime.cudaMemcpy3DParms __val
+    cdef cyruntime.cudaMemcpy3DParms* _ptr
     cdef cudaArray_t _srcArray
     cdef cudaPos _srcPos
     cdef cudaPitchedPtr _srcPtr
@@ -446,7 +443,7 @@ cdef class cudaMemcpy3DParms:
     cdef cudaPitchedPtr _dstPtr
     cdef cudaExtent _extent
 {{endif}}
-{{if 'cudaMemcpy3DPeerParms' in found_types}}
+{{if 'struct cudaMemcpy3DPeerParms' in found_types}}
 
 cdef class cudaMemcpy3DPeerParms:
     """
@@ -479,8 +476,8 @@ cdef class cudaMemcpy3DPeerParms:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemcpy3DPeerParms  __val
-    cdef ccudart.cudaMemcpy3DPeerParms* _ptr
+    cdef cyruntime.cudaMemcpy3DPeerParms __val
+    cdef cyruntime.cudaMemcpy3DPeerParms* _ptr
     cdef cudaArray_t _srcArray
     cdef cudaPos _srcPos
     cdef cudaPitchedPtr _srcPtr
@@ -489,7 +486,7 @@ cdef class cudaMemcpy3DPeerParms:
     cdef cudaPitchedPtr _dstPtr
     cdef cudaExtent _extent
 {{endif}}
-{{if 'cudaMemsetParams' in found_types}}
+{{if 'struct cudaMemsetParams' in found_types}}
 
 cdef class cudaMemsetParams:
     """
@@ -516,11 +513,10 @@ cdef class cudaMemsetParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemsetParams  __val
-    cdef ccudart.cudaMemsetParams* _ptr
-    cdef utils.HelperInputVoidPtr _cdst
+    cdef cyruntime.cudaMemsetParams __val
+    cdef cyruntime.cudaMemsetParams* _ptr
 {{endif}}
-{{if 'cudaAccessPolicyWindow' in found_types}}
+{{if 'struct cudaAccessPolicyWindow' in found_types}}
 
 cdef class cudaAccessPolicyWindow:
     """
@@ -556,11 +552,10 @@ cdef class cudaAccessPolicyWindow:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaAccessPolicyWindow  __val
-    cdef ccudart.cudaAccessPolicyWindow* _ptr
-    cdef utils.HelperInputVoidPtr _cbase_ptr
+    cdef cyruntime.cudaAccessPolicyWindow __val
+    cdef cyruntime.cudaAccessPolicyWindow* _ptr
 {{endif}}
-{{if 'cudaHostNodeParams' in found_types}}
+{{if 'struct cudaHostNodeParams' in found_types}}
 
 cdef class cudaHostNodeParams:
     """
@@ -579,16 +574,14 @@ cdef class cudaHostNodeParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaHostNodeParams  __val
-    cdef ccudart.cudaHostNodeParams* _ptr
+    cdef cyruntime.cudaHostNodeParams __val
+    cdef cyruntime.cudaHostNodeParams* _ptr
     cdef cudaHostFn_t _fn
-    cdef utils.HelperInputVoidPtr _cuserData
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_array_s:
+cdef class anon_struct1:
     """
-
     Attributes
     ----------
     array : cudaArray_t
@@ -600,14 +593,13 @@ cdef class _cudaResourceDesc_res_res_array_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc* _ptr
+    cdef cyruntime.cudaResourceDesc* _ptr
     cdef cudaArray_t _array
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_mipmap_s:
+cdef class anon_struct2:
     """
-
     Attributes
     ----------
     mipmap : cudaMipmappedArray_t
@@ -619,17 +611,16 @@ cdef class _cudaResourceDesc_res_res_mipmap_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc* _ptr
+    cdef cyruntime.cudaResourceDesc* _ptr
     cdef cudaMipmappedArray_t _mipmap
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_linear_s:
+cdef class anon_struct3:
     """
-
     Attributes
     ----------
-    devPtr : void
+    devPtr : Any
 
     desc : cudaChannelFormatDesc
 
@@ -642,18 +633,16 @@ cdef class _cudaResourceDesc_res_res_linear_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc* _ptr
-    cdef utils.HelperInputVoidPtr _cdevPtr
+    cdef cyruntime.cudaResourceDesc* _ptr
     cdef cudaChannelFormatDesc _desc
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_pitch2D_s:
+cdef class anon_struct4:
     """
-
     Attributes
     ----------
-    devPtr : void
+    devPtr : Any
 
     desc : cudaChannelFormatDesc
 
@@ -670,24 +659,22 @@ cdef class _cudaResourceDesc_res_res_pitch2D_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc* _ptr
-    cdef utils.HelperInputVoidPtr _cdevPtr
+    cdef cyruntime.cudaResourceDesc* _ptr
     cdef cudaChannelFormatDesc _desc
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_u:
+cdef class anon_union0:
     """
-
     Attributes
     ----------
-    array : _cudaResourceDesc_res_res_array_s
+    array : anon_struct1
 
-    mipmap : _cudaResourceDesc_res_res_mipmap_s
+    mipmap : anon_struct2
 
-    linear : _cudaResourceDesc_res_res_linear_s
+    linear : anon_struct3
 
-    pitch2D : _cudaResourceDesc_res_res_pitch2D_s
+    pitch2D : anon_struct4
 
 
     Methods
@@ -696,13 +683,13 @@ cdef class _cudaResourceDesc_res_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc* _ptr
-    cdef _cudaResourceDesc_res_res_array_s _array
-    cdef _cudaResourceDesc_res_res_mipmap_s _mipmap
-    cdef _cudaResourceDesc_res_res_linear_s _linear
-    cdef _cudaResourceDesc_res_res_pitch2D_s _pitch2D
+    cdef cyruntime.cudaResourceDesc* _ptr
+    cdef anon_struct1 _array
+    cdef anon_struct2 _mipmap
+    cdef anon_struct3 _linear
+    cdef anon_struct4 _pitch2D
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
 cdef class cudaResourceDesc:
     """
@@ -712,7 +699,7 @@ cdef class cudaResourceDesc:
     ----------
     resType : cudaResourceType
         Resource type
-    res : _cudaResourceDesc_res_u
+    res : anon_union0
 
 
     Methods
@@ -721,11 +708,11 @@ cdef class cudaResourceDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceDesc  __val
-    cdef ccudart.cudaResourceDesc* _ptr
-    cdef _cudaResourceDesc_res_u _res
+    cdef cyruntime.cudaResourceDesc* _val_ptr
+    cdef cyruntime.cudaResourceDesc* _ptr
+    cdef anon_union0 _res
 {{endif}}
-{{if 'cudaResourceViewDesc' in found_types}}
+{{if 'struct cudaResourceViewDesc' in found_types}}
 
 cdef class cudaResourceViewDesc:
     """
@@ -756,10 +743,10 @@ cdef class cudaResourceViewDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaResourceViewDesc  __val
-    cdef ccudart.cudaResourceViewDesc* _ptr
+    cdef cyruntime.cudaResourceViewDesc __val
+    cdef cyruntime.cudaResourceViewDesc* _ptr
 {{endif}}
-{{if 'cudaPointerAttributes' in found_types}}
+{{if 'struct cudaPointerAttributes' in found_types}}
 
 cdef class cudaPointerAttributes:
     """
@@ -793,12 +780,10 @@ cdef class cudaPointerAttributes:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaPointerAttributes  __val
-    cdef ccudart.cudaPointerAttributes* _ptr
-    cdef utils.HelperInputVoidPtr _cdevicePointer
-    cdef utils.HelperInputVoidPtr _chostPointer
+    cdef cyruntime.cudaPointerAttributes __val
+    cdef cyruntime.cudaPointerAttributes* _ptr
 {{endif}}
-{{if 'cudaFuncAttributes' in found_types}}
+{{if 'struct cudaFuncAttributes' in found_types}}
 
 cdef class cudaFuncAttributes:
     """
@@ -852,10 +837,10 @@ cdef class cudaFuncAttributes:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaFuncAttributes  __val
-    cdef ccudart.cudaFuncAttributes* _ptr
+    cdef cyruntime.cudaFuncAttributes __val
+    cdef cyruntime.cudaFuncAttributes* _ptr
 {{endif}}
-{{if 'cudaMemLocation' in found_types}}
+{{if 'struct cudaMemLocation' in found_types}}
 
 cdef class cudaMemLocation:
     """
@@ -875,10 +860,10 @@ cdef class cudaMemLocation:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemLocation  __val
-    cdef ccudart.cudaMemLocation* _ptr
+    cdef cyruntime.cudaMemLocation __val
+    cdef cyruntime.cudaMemLocation* _ptr
 {{endif}}
-{{if 'cudaMemAccessDesc' in found_types}}
+{{if 'struct cudaMemAccessDesc' in found_types}}
 
 cdef class cudaMemAccessDesc:
     """
@@ -897,11 +882,11 @@ cdef class cudaMemAccessDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemAccessDesc  __val
-    cdef ccudart.cudaMemAccessDesc* _ptr
+    cdef cyruntime.cudaMemAccessDesc __val
+    cdef cyruntime.cudaMemAccessDesc* _ptr
     cdef cudaMemLocation _location
 {{endif}}
-{{if 'cudaMemPoolProps' in found_types}}
+{{if 'struct cudaMemPoolProps' in found_types}}
 
 cdef class cudaMemPoolProps:
     """
@@ -931,12 +916,11 @@ cdef class cudaMemPoolProps:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemPoolProps  __val
-    cdef ccudart.cudaMemPoolProps* _ptr
+    cdef cyruntime.cudaMemPoolProps __val
+    cdef cyruntime.cudaMemPoolProps* _ptr
     cdef cudaMemLocation _location
-    cdef utils.HelperInputVoidPtr _cwin32SecurityAttributes
 {{endif}}
-{{if 'cudaMemPoolPtrExportData' in found_types}}
+{{if 'struct cudaMemPoolPtrExportData' in found_types}}
 
 cdef class cudaMemPoolPtrExportData:
     """
@@ -953,10 +937,10 @@ cdef class cudaMemPoolPtrExportData:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemPoolPtrExportData  __val
-    cdef ccudart.cudaMemPoolPtrExportData* _ptr
+    cdef cyruntime.cudaMemPoolPtrExportData __val
+    cdef cyruntime.cudaMemPoolPtrExportData* _ptr
 {{endif}}
-{{if 'cudaMemAllocNodeParams' in found_types}}
+{{if 'struct cudaMemAllocNodeParams' in found_types}}
 
 cdef class cudaMemAllocNodeParams:
     """
@@ -985,18 +969,17 @@ cdef class cudaMemAllocNodeParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaMemAllocNodeParams  __val
-    cdef ccudart.cudaMemAllocNodeParams* _ptr
+    cdef cyruntime.cudaMemAllocNodeParams __val
+    cdef cyruntime.cudaMemAllocNodeParams* _ptr
     cdef cudaMemPoolProps _poolProps
     cdef size_t _accessDescs_length
-    cdef ccudart.cudaMemAccessDesc* _accessDescs
-    cdef utils.HelperInputVoidPtr _cdptr
+    cdef cyruntime.cudaMemAccessDesc* _accessDescs
+
 {{endif}}
-{{if 'CUuuid_st' in found_types}}
+{{if 'struct CUuuid_st' in found_types}}
 
 cdef class CUuuid_st:
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -1008,10 +991,10 @@ cdef class CUuuid_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.CUuuid_st  __val
-    cdef ccudart.CUuuid_st* _ptr
+    cdef cyruntime.CUuuid_st __val
+    cdef cyruntime.CUuuid_st* _ptr
 {{endif}}
-{{if 'cudaDeviceProp' in found_types}}
+{{if 'struct cudaDeviceProp' in found_types}}
 
 cdef class cudaDeviceProp:
     """
@@ -1019,7 +1002,7 @@ cdef class cudaDeviceProp:
 
     Attributes
     ----------
-    name : List[char]
+    name : bytes
         ASCII string identifying device
     uuid : cudaUUID_t
         16-byte unique identifier
@@ -1202,11 +1185,11 @@ cdef class cudaDeviceProp:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaDeviceProp  __val
-    cdef ccudart.cudaDeviceProp* _ptr
+    cdef cyruntime.cudaDeviceProp __val
+    cdef cyruntime.cudaDeviceProp* _ptr
     cdef cudaUUID_t _uuid
 {{endif}}
-{{if 'cudaIpcEventHandle_st' in found_types}}
+{{if 'struct cudaIpcEventHandle_st' in found_types}}
 
 cdef class cudaIpcEventHandle_st:
     """
@@ -1223,10 +1206,10 @@ cdef class cudaIpcEventHandle_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaIpcEventHandle_st  __val
-    cdef ccudart.cudaIpcEventHandle_st* _ptr
+    cdef cyruntime.cudaIpcEventHandle_st __val
+    cdef cyruntime.cudaIpcEventHandle_st* _ptr
 {{endif}}
-{{if 'cudaIpcMemHandle_st' in found_types}}
+{{if 'struct cudaIpcMemHandle_st' in found_types}}
 
 cdef class cudaIpcMemHandle_st:
     """
@@ -1243,19 +1226,18 @@ cdef class cudaIpcMemHandle_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaIpcMemHandle_st  __val
-    cdef ccudart.cudaIpcMemHandle_st* _ptr
+    cdef cyruntime.cudaIpcMemHandle_st __val
+    cdef cyruntime.cudaIpcMemHandle_st* _ptr
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
-cdef class _cudaExternalMemoryHandleDesc_handle_handle_win32_s:
+cdef class anon_struct5:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -1264,22 +1246,19 @@ cdef class _cudaExternalMemoryHandleDesc_handle_handle_win32_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemoryHandleDesc* _ptr
-    cdef utils.HelperInputVoidPtr _chandle
-    cdef utils.HelperInputVoidPtr _cname
+    cdef cyruntime.cudaExternalMemoryHandleDesc* _ptr
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
-cdef class _cudaExternalMemoryHandleDesc_handle_u:
+cdef class anon_union1:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _cudaExternalMemoryHandleDesc_handle_handle_win32_s
+    win32 : anon_struct5
 
-    nvSciBufObject : void
+    nvSciBufObject : Any
 
 
     Methods
@@ -1288,11 +1267,10 @@ cdef class _cudaExternalMemoryHandleDesc_handle_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemoryHandleDesc* _ptr
-    cdef _cudaExternalMemoryHandleDesc_handle_handle_win32_s _win32
-    cdef utils.HelperInputVoidPtr _cnvSciBufObject
+    cdef cyruntime.cudaExternalMemoryHandleDesc* _ptr
+    cdef anon_struct5 _win32
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
 cdef class cudaExternalMemoryHandleDesc:
     """
@@ -1302,7 +1280,7 @@ cdef class cudaExternalMemoryHandleDesc:
     ----------
     type : cudaExternalMemoryHandleType
         Type of the handle
-    handle : _cudaExternalMemoryHandleDesc_handle_u
+    handle : anon_union1
 
     size : unsigned long long
         Size of the memory allocation
@@ -1315,11 +1293,11 @@ cdef class cudaExternalMemoryHandleDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemoryHandleDesc  __val
-    cdef ccudart.cudaExternalMemoryHandleDesc* _ptr
-    cdef _cudaExternalMemoryHandleDesc_handle_u _handle
+    cdef cyruntime.cudaExternalMemoryHandleDesc* _val_ptr
+    cdef cyruntime.cudaExternalMemoryHandleDesc* _ptr
+    cdef anon_union1 _handle
 {{endif}}
-{{if 'cudaExternalMemoryBufferDesc' in found_types}}
+{{if 'struct cudaExternalMemoryBufferDesc' in found_types}}
 
 cdef class cudaExternalMemoryBufferDesc:
     """
@@ -1340,10 +1318,10 @@ cdef class cudaExternalMemoryBufferDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemoryBufferDesc  __val
-    cdef ccudart.cudaExternalMemoryBufferDesc* _ptr
+    cdef cyruntime.cudaExternalMemoryBufferDesc __val
+    cdef cyruntime.cudaExternalMemoryBufferDesc* _ptr
 {{endif}}
-{{if 'cudaExternalMemoryMipmappedArrayDesc' in found_types}}
+{{if 'struct cudaExternalMemoryMipmappedArrayDesc' in found_types}}
 
 cdef class cudaExternalMemoryMipmappedArrayDesc:
     """
@@ -1370,21 +1348,20 @@ cdef class cudaExternalMemoryMipmappedArrayDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalMemoryMipmappedArrayDesc  __val
-    cdef ccudart.cudaExternalMemoryMipmappedArrayDesc* _ptr
+    cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc __val
+    cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc* _ptr
     cdef cudaChannelFormatDesc _formatDesc
     cdef cudaExtent _extent
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
-cdef class _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s:
+cdef class anon_struct6:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -1393,22 +1370,19 @@ cdef class _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr
-    cdef utils.HelperInputVoidPtr _chandle
-    cdef utils.HelperInputVoidPtr _cname
+    cdef cyruntime.cudaExternalSemaphoreHandleDesc* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
-cdef class _cudaExternalSemaphoreHandleDesc_handle_u:
+cdef class anon_union2:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s
+    win32 : anon_struct6
 
-    nvSciSyncObj : void
+    nvSciSyncObj : Any
 
 
     Methods
@@ -1417,11 +1391,10 @@ cdef class _cudaExternalSemaphoreHandleDesc_handle_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr
-    cdef _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s _win32
-    cdef utils.HelperInputVoidPtr _cnvSciSyncObj
+    cdef cyruntime.cudaExternalSemaphoreHandleDesc* _ptr
+    cdef anon_struct6 _win32
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
 cdef class cudaExternalSemaphoreHandleDesc:
     """
@@ -1431,7 +1404,7 @@ cdef class cudaExternalSemaphoreHandleDesc:
     ----------
     type : cudaExternalSemaphoreHandleType
         Type of the handle
-    handle : _cudaExternalSemaphoreHandleDesc_handle_u
+    handle : anon_union2
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -1442,15 +1415,14 @@ cdef class cudaExternalSemaphoreHandleDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreHandleDesc  __val
-    cdef ccudart.cudaExternalSemaphoreHandleDesc* _ptr
-    cdef _cudaExternalSemaphoreHandleDesc_handle_u _handle
+    cdef cyruntime.cudaExternalSemaphoreHandleDesc* _val_ptr
+    cdef cyruntime.cudaExternalSemaphoreHandleDesc* _ptr
+    cdef anon_union2 _handle
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_fence_s:
+cdef class anon_struct13:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -1462,16 +1434,15 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_fence_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u:
+cdef class anon_union5:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -1482,14 +1453,12 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr
-    cdef utils.HelperInputVoidPtr _cfence
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s:
+cdef class anon_struct14:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -1501,20 +1470,19 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_s:
+cdef class anon_struct15:
     """
-
     Attributes
     ----------
-    fence : _cudaExternalSemaphoreSignalParams_params_params_fence_s
+    fence : anon_struct13
 
-    nvSciSync : _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u
+    nvSciSync : anon_union5
 
-    keyedMutex : _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s
+    keyedMutex : anon_struct14
 
     reserved : List[unsigned int]
 
@@ -1525,12 +1493,12 @@ cdef class _cudaExternalSemaphoreSignalParams_params_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr
-    cdef _cudaExternalSemaphoreSignalParams_params_params_fence_s _fence
-    cdef _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u _nvSciSync
-    cdef _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s _keyedMutex
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _ptr
+    cdef anon_struct13 _fence
+    cdef anon_union5 _nvSciSync
+    cdef anon_struct14 _keyedMutex
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
 cdef class cudaExternalSemaphoreSignalParams:
     """
@@ -1538,7 +1506,7 @@ cdef class cudaExternalSemaphoreSignalParams:
 
     Attributes
     ----------
-    params : _cudaExternalSemaphoreSignalParams_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when cudaExternalSemaphoreSignalParams is used to signal a
@@ -1558,15 +1526,14 @@ cdef class cudaExternalSemaphoreSignalParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalParams  __val
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _ptr
-    cdef _cudaExternalSemaphoreSignalParams_params_s _params
+    cdef cyruntime.cudaExternalSemaphoreSignalParams __val
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _ptr
+    cdef anon_struct15 _params
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_fence_s:
+cdef class anon_struct16:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -1578,16 +1545,15 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_fence_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u:
+cdef class anon_union6:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -1598,14 +1564,12 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr
-    cdef utils.HelperInputVoidPtr _cfence
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s:
+cdef class anon_struct17:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -1619,20 +1583,19 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _ptr
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_s:
+cdef class anon_struct18:
     """
-
     Attributes
     ----------
-    fence : _cudaExternalSemaphoreWaitParams_params_params_fence_s
+    fence : anon_struct16
 
-    nvSciSync : _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u
+    nvSciSync : anon_union6
 
-    keyedMutex : _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s
+    keyedMutex : anon_struct17
 
     reserved : List[unsigned int]
 
@@ -1643,12 +1606,12 @@ cdef class _cudaExternalSemaphoreWaitParams_params_s:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr
-    cdef _cudaExternalSemaphoreWaitParams_params_params_fence_s _fence
-    cdef _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u _nvSciSync
-    cdef _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s _keyedMutex
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _ptr
+    cdef anon_struct16 _fence
+    cdef anon_union6 _nvSciSync
+    cdef anon_struct17 _keyedMutex
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
 cdef class cudaExternalSemaphoreWaitParams:
     """
@@ -1656,7 +1619,7 @@ cdef class cudaExternalSemaphoreWaitParams:
 
     Attributes
     ----------
-    params : _cudaExternalSemaphoreWaitParams_params_s
+    params : anon_struct18
 
     flags : unsigned int
         Only when cudaExternalSemaphoreSignalParams is used to signal a
@@ -1676,11 +1639,11 @@ cdef class cudaExternalSemaphoreWaitParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitParams  __val
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _ptr
-    cdef _cudaExternalSemaphoreWaitParams_params_s _params
+    cdef cyruntime.cudaExternalSemaphoreWaitParams __val
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _ptr
+    cdef anon_struct18 _params
 {{endif}}
-{{if 'cudaKernelNodeParams' in found_types}}
+{{if 'struct cudaKernelNodeParams' in found_types}}
 
 cdef class cudaKernelNodeParams:
     """
@@ -1707,14 +1670,13 @@ cdef class cudaKernelNodeParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaKernelNodeParams  __val
-    cdef ccudart.cudaKernelNodeParams* _ptr
-    cdef utils.HelperInputVoidPtr _cfunc
+    cdef cyruntime.cudaKernelNodeParams __val
+    cdef cyruntime.cudaKernelNodeParams* _ptr
     cdef dim3 _gridDim
     cdef dim3 _blockDim
-    cdef utils.HelperKernelParams _ckernelParams
+    cdef utils.HelperKernelParams _cykernelParams
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalNodeParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalNodeParams' in found_types}}
 
 cdef class cudaExternalSemaphoreSignalNodeParams:
     """
@@ -1736,14 +1698,16 @@ cdef class cudaExternalSemaphoreSignalNodeParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreSignalNodeParams  __val
-    cdef ccudart.cudaExternalSemaphoreSignalNodeParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreSignalNodeParams __val
+    cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* _ptr
     cdef size_t _extSemArray_length
-    cdef ccudart.cudaExternalSemaphore_t* _extSemArray
+    cdef cyruntime.cudaExternalSemaphore_t* _extSemArray
+
     cdef size_t _paramsArray_length
-    cdef ccudart.cudaExternalSemaphoreSignalParams* _paramsArray
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* _paramsArray
+
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitNodeParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitNodeParams' in found_types}}
 
 cdef class cudaExternalSemaphoreWaitNodeParams:
     """
@@ -1765,18 +1729,19 @@ cdef class cudaExternalSemaphoreWaitNodeParams:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaExternalSemaphoreWaitNodeParams  __val
-    cdef ccudart.cudaExternalSemaphoreWaitNodeParams* _ptr
+    cdef cyruntime.cudaExternalSemaphoreWaitNodeParams __val
+    cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* _ptr
     cdef size_t _extSemArray_length
-    cdef ccudart.cudaExternalSemaphore_t* _extSemArray
+    cdef cyruntime.cudaExternalSemaphore_t* _extSemArray
+
     cdef size_t _paramsArray_length
-    cdef ccudart.cudaExternalSemaphoreWaitParams* _paramsArray
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* _paramsArray
+
 {{endif}}
-{{if 'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s' in found_types}}
+{{if 'union cudaLaunchAttributeValue' in found_types}}
 
-cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s:
+cdef class anon_struct19:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -1792,13 +1757,12 @@ cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttribut
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaLaunchAttributeValue* _ptr
+    cdef cyruntime.cudaLaunchAttributeValue* _ptr
 {{endif}}
-{{if 'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s' in found_types}}
+{{if 'union cudaLaunchAttributeValue' in found_types}}
 
-cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s:
+cdef class anon_struct20:
     """
-
     Attributes
     ----------
     event : cudaEvent_t
@@ -1814,7 +1778,7 @@ cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttribut
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaLaunchAttributeValue* _ptr
+    cdef cyruntime.cudaLaunchAttributeValue* _ptr
     cdef cudaEvent_t _event
 {{endif}}
 {{if 'union cudaLaunchAttributeValue' in found_types}}
@@ -1834,13 +1798,13 @@ cdef class cudaLaunchAttributeValue:
 
     syncPolicy : cudaSynchronizationPolicy
 
-    clusterDim : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s
+    clusterDim : anon_struct19
 
     clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s
+    programmaticEvent : anon_struct20
 
     priority : int
 
@@ -1851,14 +1815,13 @@ cdef class cudaLaunchAttributeValue:
         Get memory address of class instance
 
     """
-
-    cdef ccudart.cudaLaunchAttributeValue __val
-    cdef ccudart.cudaLaunchAttributeValue* _ptr
-    {{if 'accessPolicyWindow' in found_unions['cudaLaunchAttributeValue']['members']}}cdef cudaAccessPolicyWindow _accessPolicyWindow{{endif}}
-    {{if 'clusterDim' in found_unions['cudaLaunchAttributeValue']['members']}}cdef _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s _clusterDim{{endif}}
-    {{if 'programmaticEvent' in found_unions['cudaLaunchAttributeValue']['members']}}cdef _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s _programmaticEvent{{endif}}
+    cdef cyruntime.cudaLaunchAttributeValue __val
+    cdef cyruntime.cudaLaunchAttributeValue* _ptr
+    cdef cudaAccessPolicyWindow _accessPolicyWindow
+    cdef anon_struct19 _clusterDim
+    cdef anon_struct20 _programmaticEvent
 {{endif}}
-{{if 'cudaLaunchAttribute_st' in found_types}}
+{{if 'struct cudaLaunchAttribute_st' in found_types}}
 
 cdef class cudaLaunchAttribute_st:
     """
@@ -1877,11 +1840,11 @@ cdef class cudaLaunchAttribute_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaLaunchAttribute_st  __val
-    cdef ccudart.cudaLaunchAttribute_st* _ptr
+    cdef cyruntime.cudaLaunchAttribute_st __val
+    cdef cyruntime.cudaLaunchAttribute_st* _ptr
     cdef cudaLaunchAttributeValue _val
 {{endif}}
-{{if 'cudaTextureDesc' in found_types}}
+{{if 'struct cudaTextureDesc' in found_types}}
 
 cdef class cudaTextureDesc:
     """
@@ -1920,14 +1883,13 @@ cdef class cudaTextureDesc:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaTextureDesc  __val
-    cdef ccudart.cudaTextureDesc* _ptr
+    cdef cyruntime.cudaTextureDesc __val
+    cdef cyruntime.cudaTextureDesc* _ptr
 {{endif}}
-{{if 'cudaTextureDesc_v2' in found_types}}
+{{if 'struct cudaTextureDesc_v2' in found_types}}
 
 cdef class cudaTextureDesc_v2:
     """
-
     Attributes
     ----------
     addressMode : List[cudaTextureAddressMode]
@@ -1963,10 +1925,10 @@ cdef class cudaTextureDesc_v2:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaTextureDesc_v2  __val
-    cdef ccudart.cudaTextureDesc_v2* _ptr
+    cdef cyruntime.cudaTextureDesc_v2 __val
+    cdef cyruntime.cudaTextureDesc_v2* _ptr
 {{endif}}
-{{if True or 'cudaEglPlaneDesc_st' in found_types}}
+{{if True}}
 
 cdef class cudaEglPlaneDesc_st:
     """
@@ -1996,15 +1958,14 @@ cdef class cudaEglPlaneDesc_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaEglPlaneDesc_st  __val
-    cdef ccudart.cudaEglPlaneDesc_st* _ptr
+    cdef cyruntime.cudaEglPlaneDesc_st __val
+    cdef cyruntime.cudaEglPlaneDesc_st* _ptr
     cdef cudaChannelFormatDesc _channelDesc
 {{endif}}
-{{if True or 'cudaEglFrame_st' in found_types}}
+{{if True}}
 
-cdef class _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
+cdef class anon_union7:
     """
-
     Attributes
     ----------
     pArray : List[cudaArray_t]
@@ -2018,9 +1979,9 @@ cdef class _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaEglFrame_st* _ptr
+    cdef cyruntime.cudaEglFrame_st* _ptr
 {{endif}}
-{{if True or 'cudaEglFrame_st' in found_types}}
+{{if True}}
 
 cdef class cudaEglFrame_st:
     """
@@ -2035,7 +1996,7 @@ cdef class cudaEglFrame_st:
 
     Attributes
     ----------
-    frame : _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u
+    frame : anon_union7
 
     planeDesc : List[cudaEglPlaneDesc]
         CUDA EGL Plane Descriptor cudaEglPlaneDesc
@@ -2052,15 +2013,14 @@ cdef class cudaEglFrame_st:
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaEglFrame_st  __val
-    cdef ccudart.cudaEglFrame_st* _ptr
-    cdef _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u _frame
+    cdef cyruntime.cudaEglFrame_st* _val_ptr
+    cdef cyruntime.cudaEglFrame_st* _ptr
+    cdef anon_union7 _frame
 {{endif}}
 {{if 'CUuuid' in found_types}}
 
 cdef class CUuuid(CUuuid_st):
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -2078,7 +2038,6 @@ cdef class CUuuid(CUuuid_st):
 
 cdef class cudaUUID_t(CUuuid_st):
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -2151,7 +2110,7 @@ cdef class cudaLaunchAttribute(cudaLaunchAttribute_st):
     """
     pass
 {{endif}}
-{{if True or 'cudaStreamAttrValue' in found_types}}
+{{if True}}
 
 cdef class cudaStreamAttrValue(cudaLaunchAttributeValue):
     """
@@ -2168,13 +2127,13 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue):
 
     syncPolicy : cudaSynchronizationPolicy
 
-    clusterDim : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s
+    clusterDim : anon_struct19
 
     clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s
+    programmaticEvent : anon_struct20
 
     priority : int
 
@@ -2187,7 +2146,7 @@ cdef class cudaStreamAttrValue(cudaLaunchAttributeValue):
     """
     pass
 {{endif}}
-{{if True or 'cudaKernelNodeAttrValue' in found_types}}
+{{if True}}
 
 cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue):
     """
@@ -2204,13 +2163,13 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue):
 
     syncPolicy : cudaSynchronizationPolicy
 
-    clusterDim : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s
+    clusterDim : anon_struct19
 
     clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s
+    programmaticEvent : anon_struct20
 
     priority : int
 
@@ -2223,7 +2182,7 @@ cdef class cudaKernelNodeAttrValue(cudaLaunchAttributeValue):
     """
     pass
 {{endif}}
-{{if True or 'cudaEglPlaneDesc' in found_types}}
+{{if True}}
 
 cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st):
     """
@@ -2255,7 +2214,7 @@ cdef class cudaEglPlaneDesc(cudaEglPlaneDesc_st):
     """
     pass
 {{endif}}
-{{if True or 'cudaEglFrame' in found_types}}
+{{if True}}
 
 cdef class cudaEglFrame(cudaEglFrame_st):
     """
@@ -2270,7 +2229,7 @@ cdef class cudaEglFrame(cudaEglFrame_st):
 
     Attributes
     ----------
-    frame : _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u
+    frame : anon_union7
 
     planeDesc : List[cudaEglPlaneDesc]
         CUDA EGL Plane Descriptor cudaEglPlaneDesc
@@ -2291,12 +2250,11 @@ cdef class cudaEglFrame(cudaEglFrame_st):
 {{endif}}
 {{if 'cudaStream_t' in found_types}}
 
-cdef class cudaStream_t(cuda.CUstream):
+cdef class cudaStream_t(driver.CUstream):
     """
 
     CUDA stream
 
-
     Methods
     -------
     getPtr()
@@ -2305,13 +2263,13 @@ cdef class cudaStream_t(cuda.CUstream):
     """
     pass
 {{endif}}
+
 {{if 'cudaEvent_t' in found_types}}
 
-cdef class cudaEvent_t(cuda.CUevent):
+cdef class cudaEvent_t(driver.CUevent):
     """
 
-    CUDA event
-
+    CUDA event types
 
     Methods
     -------
@@ -2321,14 +2279,14 @@ cdef class cudaEvent_t(cuda.CUevent):
     """
     pass
 {{endif}}
+
 {{if 'cudaGraph_t' in found_types}}
 
-cdef class cudaGraph_t(cuda.CUgraph):
+cdef class cudaGraph_t(driver.CUgraph):
     """
 
     CUDA graph
 
-
     Methods
     -------
     getPtr()
@@ -2337,13 +2295,13 @@ cdef class cudaGraph_t(cuda.CUgraph):
     """
     pass
 {{endif}}
+
 {{if 'cudaGraphNode_t' in found_types}}
 
-cdef class cudaGraphNode_t(cuda.CUgraphNode):
+cdef class cudaGraphNode_t(driver.CUgraphNode):
     """
 
-    CUDA graph node
-
+    CUDA graph node.
 
     Methods
     -------
@@ -2353,14 +2311,14 @@ cdef class cudaGraphNode_t(cuda.CUgraphNode):
     """
     pass
 {{endif}}
+
 {{if 'cudaUserObject_t' in found_types}}
 
-cdef class cudaUserObject_t(cuda.CUuserObject):
+cdef class cudaUserObject_t(driver.CUuserObject):
     """
 
     CUDA user object for graphs
 
-
     Methods
     -------
     getPtr()
@@ -2369,14 +2327,14 @@ cdef class cudaUserObject_t(cuda.CUuserObject):
     """
     pass
 {{endif}}
+
 {{if 'cudaFunction_t' in found_types}}
 
-cdef class cudaFunction_t(cuda.CUfunction):
+cdef class cudaFunction_t(driver.CUfunction):
     """
 
     CUDA function
 
-
     Methods
     -------
     getPtr()
@@ -2385,14 +2343,14 @@ cdef class cudaFunction_t(cuda.CUfunction):
     """
     pass
 {{endif}}
+
 {{if 'cudaMemPool_t' in found_types}}
 
-cdef class cudaMemPool_t(cuda.CUmemoryPool):
+cdef class cudaMemPool_t(driver.CUmemoryPool):
     """
 
     CUDA memory pool
 
-
     Methods
     -------
     getPtr()
@@ -2401,13 +2359,13 @@ cdef class cudaMemPool_t(cuda.CUmemoryPool):
     """
     pass
 {{endif}}
+
 {{if 'cudaGraphExec_t' in found_types}}
 
-cdef class cudaGraphExec_t(cuda.CUgraphExec):
+cdef class cudaGraphExec_t(driver.CUgraphExec):
     """
 
-    CUDA executable graph
-
+    CUDA executable (launchable) graph
 
     Methods
     -------
@@ -2417,14 +2375,14 @@ cdef class cudaGraphExec_t(cuda.CUgraphExec):
     """
     pass
 {{endif}}
-{{if True or 'cudaEglStreamConnection' in found_types}}
 
-cdef class cudaEglStreamConnection(cuda.CUeglStreamConnection):
+{{if True}}
+
+cdef class cudaEglStreamConnection(driver.CUeglStreamConnection):
     """
 
     CUDA EGLSream Connection
 
-
     Methods
     -------
     getPtr()
@@ -2433,39 +2391,44 @@ cdef class cudaEglStreamConnection(cuda.CUeglStreamConnection):
     """
     pass
 {{endif}}
-{{if True or 'GLenum' in found_types}}
 
-cdef class GLenum:
+{{if 'cudaSurfaceObject_t' in found_types}}
+
+cdef class cudaSurfaceObject_t:
     """
 
+    An opaque value that represents a CUDA Surface object
+
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccudart.GLenum  __val
-    cdef ccudart.GLenum* _ptr
+    cdef cyruntime.cudaSurfaceObject_t  __val
+    cdef cyruntime.cudaSurfaceObject_t* _ptr
 {{endif}}
 
-{{if True or 'GLuint' in found_types}}
+{{if 'cudaTextureObject_t' in found_types}}
 
-cdef class GLuint:
+cdef class cudaTextureObject_t:
     """
 
+    An opaque value that represents a CUDA texture object
+
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccudart.GLuint  __val
-    cdef ccudart.GLuint* _ptr
+    cdef cyruntime.cudaTextureObject_t  __val
+    cdef cyruntime.cudaTextureObject_t* _ptr
 {{endif}}
 
-{{if True or 'EGLint' in found_types}}
+{{if True}}
 
-cdef class EGLint:
+cdef class GLenum:
     """
 
     Methods
@@ -2474,13 +2437,13 @@ cdef class EGLint:
         Get memory address of class instance
 
     """
-    cdef ccudart.EGLint  __val
-    cdef ccudart.EGLint* _ptr
+    cdef cyruntime.GLenum  __val
+    cdef cyruntime.GLenum* _ptr
 {{endif}}
 
-{{if True or 'VdpDevice' in found_types}}
+{{if True}}
 
-cdef class VdpDevice:
+cdef class GLuint:
     """
 
     Methods
@@ -2489,13 +2452,13 @@ cdef class VdpDevice:
         Get memory address of class instance
 
     """
-    cdef ccudart.VdpDevice  __val
-    cdef ccudart.VdpDevice* _ptr
+    cdef cyruntime.GLuint  __val
+    cdef cyruntime.GLuint* _ptr
 {{endif}}
 
-{{if True or 'VdpGetProcAddress' in found_types}}
+{{if True}}
 
-cdef class VdpGetProcAddress:
+cdef class EGLint:
     """
 
     Methods
@@ -2504,13 +2467,13 @@ cdef class VdpGetProcAddress:
         Get memory address of class instance
 
     """
-    cdef ccudart.VdpGetProcAddress  __val
-    cdef ccudart.VdpGetProcAddress* _ptr
+    cdef cyruntime.EGLint  __val
+    cdef cyruntime.EGLint* _ptr
 {{endif}}
 
-{{if True or 'VdpVideoSurface' in found_types}}
+{{if True}}
 
-cdef class VdpVideoSurface:
+cdef class VdpDevice:
     """
 
     Methods
@@ -2519,13 +2482,13 @@ cdef class VdpVideoSurface:
         Get memory address of class instance
 
     """
-    cdef ccudart.VdpVideoSurface  __val
-    cdef ccudart.VdpVideoSurface* _ptr
+    cdef cyruntime.VdpDevice  __val
+    cdef cyruntime.VdpDevice* _ptr
 {{endif}}
 
-{{if True or 'VdpOutputSurface' in found_types}}
+{{if True}}
 
-cdef class VdpOutputSurface:
+cdef class VdpGetProcAddress:
     """
 
     Methods
@@ -2534,40 +2497,36 @@ cdef class VdpOutputSurface:
         Get memory address of class instance
 
     """
-    cdef ccudart.VdpOutputSurface  __val
-    cdef ccudart.VdpOutputSurface* _ptr
+    cdef cyruntime.VdpGetProcAddress  __val
+    cdef cyruntime.VdpGetProcAddress* _ptr
 {{endif}}
 
-{{if 'cudaSurfaceObject_t' in found_types}}
+{{if True}}
 
-cdef class cudaSurfaceObject_t:
+cdef class VdpVideoSurface:
     """
 
-    An opaque value that represents a CUDA Surface object
-
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaSurfaceObject_t  __val
-    cdef ccudart.cudaSurfaceObject_t* _ptr
+    cdef cyruntime.VdpVideoSurface  __val
+    cdef cyruntime.VdpVideoSurface* _ptr
 {{endif}}
 
-{{if 'cudaTextureObject_t' in found_types}}
+{{if True}}
 
-cdef class cudaTextureObject_t:
+cdef class VdpOutputSurface:
     """
 
-    An opaque value that represents a CUDA texture object
-
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    cdef ccudart.cudaTextureObject_t  __val
-    cdef ccudart.cudaTextureObject_t* _ptr
+    cdef cyruntime.VdpOutputSurface  __val
+    cdef cyruntime.VdpOutputSurface* _ptr
 {{endif}}
diff --git a/cuda/cudart.pyx.in b/cuda/cuda/bindings/runtime.pyx.in
similarity index 73%
rename from cuda/cudart.pyx.in
rename to cuda/cuda/bindings/runtime.pyx.in
index cede4cde..7000e4ac 100644
--- a/cuda/cudart.pyx.in
+++ b/cuda/cuda/bindings/runtime.pyx.in
@@ -1,4 +1,4 @@
-# Copyright 2021-2022 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -10,14 +10,14 @@ from enum import IntEnum
 import cython
 import ctypes
 from libc.stdlib cimport calloc, free
-from libc.string cimport memcpy
+from libc cimport string
 from libc.stdint cimport int32_t, uint32_t, int64_t, uint64_t
 from libc.stddef cimport wchar_t
 from libc.limits cimport CHAR_MIN
 from libcpp.vector cimport vector
 from cpython.buffer cimport PyObject_CheckBuffer, PyObject_GetBuffer, PyBuffer_Release, PyBUF_SIMPLE, PyBUF_ANY_CONTIGUOUS
 from cpython.bytes cimport PyBytes_FromStringAndSize
-import cuda.cuda
+import cuda.bindings.driver
 
 ctypedef unsigned long long signed_char_ptr
 ctypedef unsigned long long unsigned_char_ptr
@@ -36,46 +36,47 @@ ctypedef unsigned long long int32_t_ptr
 ctypedef unsigned long long int64_t_ptr
 ctypedef unsigned long long unsigned_ptr
 ctypedef unsigned long long unsigned_long_long_ptr
+ctypedef unsigned long long long_long_ptr
 ctypedef unsigned long long size_t_ptr
 ctypedef unsigned long long float_ptr
 ctypedef unsigned long long double_ptr
 ctypedef unsigned long long void_ptr
 
 #: Default page-locked allocation flag
-cudaHostAllocDefault = ccudart.cudaHostAllocDefault
+cudaHostAllocDefault = cyruntime.cudaHostAllocDefault
 
 #: Pinned memory accessible by all CUDA contexts
-cudaHostAllocPortable = ccudart.cudaHostAllocPortable
+cudaHostAllocPortable = cyruntime.cudaHostAllocPortable
 
 #: Map allocation into device space
-cudaHostAllocMapped = ccudart.cudaHostAllocMapped
+cudaHostAllocMapped = cyruntime.cudaHostAllocMapped
 
 #: Write-combined memory
-cudaHostAllocWriteCombined = ccudart.cudaHostAllocWriteCombined
+cudaHostAllocWriteCombined = cyruntime.cudaHostAllocWriteCombined
 
 #: Default host memory registration flag
-cudaHostRegisterDefault = ccudart.cudaHostRegisterDefault
+cudaHostRegisterDefault = cyruntime.cudaHostRegisterDefault
 
 #: Pinned memory accessible by all CUDA contexts
-cudaHostRegisterPortable = ccudart.cudaHostRegisterPortable
+cudaHostRegisterPortable = cyruntime.cudaHostRegisterPortable
 
 #: Map registered memory into device space
-cudaHostRegisterMapped = ccudart.cudaHostRegisterMapped
+cudaHostRegisterMapped = cyruntime.cudaHostRegisterMapped
 
 #: Memory-mapped I/O space
-cudaHostRegisterIoMemory = ccudart.cudaHostRegisterIoMemory
+cudaHostRegisterIoMemory = cyruntime.cudaHostRegisterIoMemory
 
 #: Memory-mapped read-only
-cudaHostRegisterReadOnly = ccudart.cudaHostRegisterReadOnly
+cudaHostRegisterReadOnly = cyruntime.cudaHostRegisterReadOnly
 
 #: Default peer addressing enable flag
-cudaPeerAccessDefault = ccudart.cudaPeerAccessDefault
+cudaPeerAccessDefault = cyruntime.cudaPeerAccessDefault
 
 #: Default stream flag
-cudaStreamDefault = ccudart.cudaStreamDefault
+cudaStreamDefault = cyruntime.cudaStreamDefault
 
 #: Stream does not synchronize with stream 0 (the NULL stream)
-cudaStreamNonBlocking = ccudart.cudaStreamNonBlocking
+cudaStreamNonBlocking = cyruntime.cudaStreamNonBlocking
 
 #: Legacy stream handle
 #:
@@ -83,7 +84,7 @@ cudaStreamNonBlocking = ccudart.cudaStreamNonBlocking
 #: stream with legacy synchronization behavior.
 #:
 #: See details of the \link_sync_behavior
-cudaStreamLegacy = ccudart.cudaStreamLegacy
+cudaStreamLegacy = cyruntime.cudaStreamLegacy
 
 #: Per-thread stream handle
 #:
@@ -91,138 +92,138 @@ cudaStreamLegacy = ccudart.cudaStreamLegacy
 #: stream with per-thread synchronization behavior.
 #:
 #: See details of the \link_sync_behavior
-cudaStreamPerThread = ccudart.cudaStreamPerThread
+cudaStreamPerThread = cyruntime.cudaStreamPerThread
 
 #: Default event flag
-cudaEventDefault = ccudart.cudaEventDefault
+cudaEventDefault = cyruntime.cudaEventDefault
 
 #: Event uses blocking synchronization
-cudaEventBlockingSync = ccudart.cudaEventBlockingSync
+cudaEventBlockingSync = cyruntime.cudaEventBlockingSync
 
 #: Event will not record timing data
-cudaEventDisableTiming = ccudart.cudaEventDisableTiming
+cudaEventDisableTiming = cyruntime.cudaEventDisableTiming
 
 #: Event is suitable for interprocess use. cudaEventDisableTiming must be
 #: set
-cudaEventInterprocess = ccudart.cudaEventInterprocess
+cudaEventInterprocess = cyruntime.cudaEventInterprocess
 
 #: Default event record flag
-cudaEventRecordDefault = ccudart.cudaEventRecordDefault
+cudaEventRecordDefault = cyruntime.cudaEventRecordDefault
 
 #: Event is captured in the graph as an external event node when performing
 #: stream capture
-cudaEventRecordExternal = ccudart.cudaEventRecordExternal
+cudaEventRecordExternal = cyruntime.cudaEventRecordExternal
 
 #: Default event wait flag
-cudaEventWaitDefault = ccudart.cudaEventWaitDefault
+cudaEventWaitDefault = cyruntime.cudaEventWaitDefault
 
 #: Event is captured in the graph as an external event node when performing
 #: stream capture
-cudaEventWaitExternal = ccudart.cudaEventWaitExternal
+cudaEventWaitExternal = cyruntime.cudaEventWaitExternal
 
 #: Device flag - Automatic scheduling
-cudaDeviceScheduleAuto = ccudart.cudaDeviceScheduleAuto
+cudaDeviceScheduleAuto = cyruntime.cudaDeviceScheduleAuto
 
 #: Device flag - Spin default scheduling
-cudaDeviceScheduleSpin = ccudart.cudaDeviceScheduleSpin
+cudaDeviceScheduleSpin = cyruntime.cudaDeviceScheduleSpin
 
 #: Device flag - Yield default scheduling
-cudaDeviceScheduleYield = ccudart.cudaDeviceScheduleYield
+cudaDeviceScheduleYield = cyruntime.cudaDeviceScheduleYield
 
 #: Device flag - Use blocking synchronization
-cudaDeviceScheduleBlockingSync = ccudart.cudaDeviceScheduleBlockingSync
+cudaDeviceScheduleBlockingSync = cyruntime.cudaDeviceScheduleBlockingSync
 
 #: Device flag - Use blocking synchronization [Deprecated]
-cudaDeviceBlockingSync = ccudart.cudaDeviceBlockingSync
+cudaDeviceBlockingSync = cyruntime.cudaDeviceBlockingSync
 
 #: Device schedule flags mask
-cudaDeviceScheduleMask = ccudart.cudaDeviceScheduleMask
+cudaDeviceScheduleMask = cyruntime.cudaDeviceScheduleMask
 
 #: Device flag - Support mapped pinned allocations
-cudaDeviceMapHost = ccudart.cudaDeviceMapHost
+cudaDeviceMapHost = cyruntime.cudaDeviceMapHost
 
 #: Device flag - Keep local memory allocation after launch
-cudaDeviceLmemResizeToMax = ccudart.cudaDeviceLmemResizeToMax
+cudaDeviceLmemResizeToMax = cyruntime.cudaDeviceLmemResizeToMax
 
 #: Device flags mask
-cudaDeviceMask = ccudart.cudaDeviceMask
+cudaDeviceMask = cyruntime.cudaDeviceMask
 
 #: Default CUDA array allocation flag
-cudaArrayDefault = ccudart.cudaArrayDefault
+cudaArrayDefault = cyruntime.cudaArrayDefault
 
 #: Must be set in cudaMalloc3DArray to create a layered CUDA array
-cudaArrayLayered = ccudart.cudaArrayLayered
+cudaArrayLayered = cyruntime.cudaArrayLayered
 
 #: Must be set in cudaMallocArray or cudaMalloc3DArray in order to bind
 #: surfaces to the CUDA array
-cudaArraySurfaceLoadStore = ccudart.cudaArraySurfaceLoadStore
+cudaArraySurfaceLoadStore = cyruntime.cudaArraySurfaceLoadStore
 
 #: Must be set in cudaMalloc3DArray to create a cubemap CUDA array
-cudaArrayCubemap = ccudart.cudaArrayCubemap
+cudaArrayCubemap = cyruntime.cudaArrayCubemap
 
 #: Must be set in cudaMallocArray or cudaMalloc3DArray in order to perform
 #: texture gather operations on the CUDA array
-cudaArrayTextureGather = ccudart.cudaArrayTextureGather
+cudaArrayTextureGather = cyruntime.cudaArrayTextureGather
 
 #: Must be set in cudaExternalMemoryGetMappedMipmappedArray if the
 #: mipmapped array is used as a color target in a graphics API
-cudaArrayColorAttachment = ccudart.cudaArrayColorAttachment
+cudaArrayColorAttachment = cyruntime.cudaArrayColorAttachment
 
 #: Must be set in cudaMallocArray, cudaMalloc3DArray or
 #: cudaMallocMipmappedArray in order to create a sparse CUDA array or CUDA
 #: mipmapped array
-cudaArraySparse = ccudart.cudaArraySparse
+cudaArraySparse = cyruntime.cudaArraySparse
 
 #: Must be set in cudaMallocArray, cudaMalloc3DArray or
 #: cudaMallocMipmappedArray in order to create a deferred mapping CUDA
 #: array or CUDA mipmapped array
-cudaArrayDeferredMapping = ccudart.cudaArrayDeferredMapping
+cudaArrayDeferredMapping = cyruntime.cudaArrayDeferredMapping
 
 #: Automatically enable peer access between remote devices as needed
-cudaIpcMemLazyEnablePeerAccess = ccudart.cudaIpcMemLazyEnablePeerAccess
+cudaIpcMemLazyEnablePeerAccess = cyruntime.cudaIpcMemLazyEnablePeerAccess
 
 #: Memory can be accessed by any stream on any device
-cudaMemAttachGlobal = ccudart.cudaMemAttachGlobal
+cudaMemAttachGlobal = cyruntime.cudaMemAttachGlobal
 
 #: Memory cannot be accessed by any stream on any device
-cudaMemAttachHost = ccudart.cudaMemAttachHost
+cudaMemAttachHost = cyruntime.cudaMemAttachHost
 
 #: Memory can only be accessed by a single stream on the associated device
-cudaMemAttachSingle = ccudart.cudaMemAttachSingle
+cudaMemAttachSingle = cyruntime.cudaMemAttachSingle
 
 #: Default behavior
-cudaOccupancyDefault = ccudart.cudaOccupancyDefault
+cudaOccupancyDefault = cyruntime.cudaOccupancyDefault
 
 #: Assume global caching is enabled and cannot be automatically turned off
-cudaOccupancyDisableCachingOverride = ccudart.cudaOccupancyDisableCachingOverride
+cudaOccupancyDisableCachingOverride = cyruntime.cudaOccupancyDisableCachingOverride
 
 #: Device id that represents the CPU
-cudaCpuDeviceId = ccudart.cudaCpuDeviceId
+cudaCpuDeviceId = cyruntime.cudaCpuDeviceId
 
 #: Device id that represents an invalid device
-cudaInvalidDeviceId = ccudart.cudaInvalidDeviceId
+cudaInvalidDeviceId = cyruntime.cudaInvalidDeviceId
 
 #: If set, each kernel launched as part of
 #: :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice` only waits for prior
 #: work in the stream corresponding to that GPU to complete before the
 #: kernel begins execution.
-cudaCooperativeLaunchMultiDeviceNoPreSync = ccudart.cudaCooperativeLaunchMultiDeviceNoPreSync
+cudaCooperativeLaunchMultiDeviceNoPreSync = cyruntime.cudaCooperativeLaunchMultiDeviceNoPreSync
 
 #: If set, any subsequent work pushed in a stream that participated in a
 #: call to :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice` will only
 #: wait for the kernel launched on the GPU corresponding to that stream to
 #: complete before it begins execution.
-cudaCooperativeLaunchMultiDeviceNoPostSync = ccudart.cudaCooperativeLaunchMultiDeviceNoPostSync
+cudaCooperativeLaunchMultiDeviceNoPostSync = cyruntime.cudaCooperativeLaunchMultiDeviceNoPostSync
 
 #: Indicates that the layered sparse CUDA array or CUDA mipmapped array has
 #: a single mip tail region for all layers
-cudaArraySparsePropertiesSingleMipTail = ccudart.cudaArraySparsePropertiesSingleMipTail
+cudaArraySparsePropertiesSingleMipTail = cyruntime.cudaArraySparsePropertiesSingleMipTail
 
 #: CUDA IPC Handle Size
-CUDA_IPC_HANDLE_SIZE = ccudart.CUDA_IPC_HANDLE_SIZE
+CUDA_IPC_HANDLE_SIZE = cyruntime.CUDA_IPC_HANDLE_SIZE
 
 #: Indicates that the external memory object is a dedicated resource
-cudaExternalMemoryDedicated = ccudart.cudaExternalMemoryDedicated
+cudaExternalMemoryDedicated = cyruntime.cudaExternalMemoryDedicated
 
 #: When the /p flags parameter of
 #: :py:obj:`~.cudaExternalSemaphoreSignalParams` contains this flag, it
@@ -232,7 +233,7 @@ cudaExternalMemoryDedicated = ccudart.cudaExternalMemoryDedicated
 #: :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are
 #: performed by default to ensure data coherency with other importers of
 #: the same NvSciBuf memory objects.
-cudaExternalSemaphoreSignalSkipNvSciBufMemSync = ccudart.cudaExternalSemaphoreSignalSkipNvSciBufMemSync
+cudaExternalSemaphoreSignalSkipNvSciBufMemSync = cyruntime.cudaExternalSemaphoreSignalSkipNvSciBufMemSync
 
 #: When the /p flags parameter of
 #: :py:obj:`~.cudaExternalSemaphoreWaitParams` contains this flag, it
@@ -242,57 +243,67 @@ cudaExternalSemaphoreSignalSkipNvSciBufMemSync = ccudart.cudaExternalSemaphoreSi
 #: :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are
 #: performed by default to ensure data coherency with other importers of
 #: the same NvSciBuf memory objects.
-cudaExternalSemaphoreWaitSkipNvSciBufMemSync = ccudart.cudaExternalSemaphoreWaitSkipNvSciBufMemSync
+cudaExternalSemaphoreWaitSkipNvSciBufMemSync = cyruntime.cudaExternalSemaphoreWaitSkipNvSciBufMemSync
 
 #: When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to
 #: this, it indicates that application need signaler specific NvSciSyncAttr
 #: to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`.
-cudaNvSciSyncAttrSignal = ccudart.cudaNvSciSyncAttrSignal
+cudaNvSciSyncAttrSignal = cyruntime.cudaNvSciSyncAttrSignal
 
 #: When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to
 #: this, it indicates that application need waiter specific NvSciSyncAttr
 #: to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`.
-cudaNvSciSyncAttrWait = ccudart.cudaNvSciSyncAttrWait
+cudaNvSciSyncAttrWait = cyruntime.cudaNvSciSyncAttrWait
 
-cudaKernelNodeAttributeClusterDimension = ccudart.cudaKernelNodeAttributeClusterDimension
+cudaStreamAttributeAccessPolicyWindow = cyruntime.cudaStreamAttributeAccessPolicyWindow
 
-cudaKernelNodeAttributeClusterSchedulingPolicyPreference = ccudart.cudaKernelNodeAttributeClusterSchedulingPolicyPreference
+cudaStreamAttributeSynchronizationPolicy = cyruntime.cudaStreamAttributeSynchronizationPolicy
 
-cudaSurfaceType1D = ccudart.cudaSurfaceType1D
+cudaKernelNodeAttributeAccessPolicyWindow = cyruntime.cudaKernelNodeAttributeAccessPolicyWindow
 
-cudaSurfaceType2D = ccudart.cudaSurfaceType2D
+cudaKernelNodeAttributeCooperative = cyruntime.cudaKernelNodeAttributeCooperative
 
-cudaSurfaceType3D = ccudart.cudaSurfaceType3D
+cudaKernelNodeAttributePriority = cyruntime.cudaKernelNodeAttributePriority
 
-cudaSurfaceTypeCubemap = ccudart.cudaSurfaceTypeCubemap
+cudaKernelNodeAttributeClusterDimension = cyruntime.cudaKernelNodeAttributeClusterDimension
 
-cudaSurfaceType1DLayered = ccudart.cudaSurfaceType1DLayered
+cudaKernelNodeAttributeClusterSchedulingPolicyPreference = cyruntime.cudaKernelNodeAttributeClusterSchedulingPolicyPreference
 
-cudaSurfaceType2DLayered = ccudart.cudaSurfaceType2DLayered
+cudaSurfaceType1D = cyruntime.cudaSurfaceType1D
 
-cudaSurfaceTypeCubemapLayered = ccudart.cudaSurfaceTypeCubemapLayered
+cudaSurfaceType2D = cyruntime.cudaSurfaceType2D
 
-cudaTextureType1D = ccudart.cudaTextureType1D
+cudaSurfaceType3D = cyruntime.cudaSurfaceType3D
 
-cudaTextureType2D = ccudart.cudaTextureType2D
+cudaSurfaceTypeCubemap = cyruntime.cudaSurfaceTypeCubemap
 
-cudaTextureType3D = ccudart.cudaTextureType3D
+cudaSurfaceType1DLayered = cyruntime.cudaSurfaceType1DLayered
 
-cudaTextureTypeCubemap = ccudart.cudaTextureTypeCubemap
+cudaSurfaceType2DLayered = cyruntime.cudaSurfaceType2DLayered
 
-cudaTextureType1DLayered = ccudart.cudaTextureType1DLayered
+cudaSurfaceTypeCubemapLayered = cyruntime.cudaSurfaceTypeCubemapLayered
 
-cudaTextureType2DLayered = ccudart.cudaTextureType2DLayered
+cudaTextureType1D = cyruntime.cudaTextureType1D
 
-cudaTextureTypeCubemapLayered = ccudart.cudaTextureTypeCubemapLayered
+cudaTextureType2D = cyruntime.cudaTextureType2D
+
+cudaTextureType3D = cyruntime.cudaTextureType3D
+
+cudaTextureTypeCubemap = cyruntime.cudaTextureTypeCubemap
+
+cudaTextureType1DLayered = cyruntime.cudaTextureType1DLayered
+
+cudaTextureType2DLayered = cyruntime.cudaTextureType2DLayered
+
+cudaTextureTypeCubemapLayered = cyruntime.cudaTextureTypeCubemapLayered
 
 #: CUDA Runtime API Version
-CUDART_VERSION = ccudart.CUDART_VERSION
+CUDART_VERSION = cyruntime.CUDART_VERSION
 
-__CUDART_API_VERSION = ccudart.__CUDART_API_VERSION
+__CUDART_API_VERSION = cyruntime.__CUDART_API_VERSION
 
 #: Maximum number of planes per frame
-CUDA_EGL_MAX_PLANES = ccudart.CUDA_EGL_MAX_PLANES
+CUDA_EGL_MAX_PLANES = cyruntime.CUDA_EGL_MAX_PLANES
 
 {{if 'cudaError' in found_types}}
 
@@ -305,46 +316,46 @@ class cudaError_t(IntEnum):
     #: The API call returned with no errors. In the case of query calls,
     #: this also means that the operation being queried is complete (see
     #: :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`).
-    cudaSuccess = ccudart.cudaError.cudaSuccess{{endif}}
+    cudaSuccess = cyruntime.cudaError.cudaSuccess{{endif}}
     {{if 'cudaErrorInvalidValue' in found_values}}
 
     #: This indicates that one or more of the parameters passed to the API
     #: call is not within an acceptable range of values.
-    cudaErrorInvalidValue = ccudart.cudaError.cudaErrorInvalidValue{{endif}}
+    cudaErrorInvalidValue = cyruntime.cudaError.cudaErrorInvalidValue{{endif}}
     {{if 'cudaErrorMemoryAllocation' in found_values}}
 
     #: The API call failed because it was unable to allocate enough memory
     #: to perform the requested operation.
-    cudaErrorMemoryAllocation = ccudart.cudaError.cudaErrorMemoryAllocation{{endif}}
+    cudaErrorMemoryAllocation = cyruntime.cudaError.cudaErrorMemoryAllocation{{endif}}
     {{if 'cudaErrorInitializationError' in found_values}}
 
     #: The API call failed because the CUDA driver and runtime could not be
     #: initialized.
-    cudaErrorInitializationError = ccudart.cudaError.cudaErrorInitializationError{{endif}}
+    cudaErrorInitializationError = cyruntime.cudaError.cudaErrorInitializationError{{endif}}
     {{if 'cudaErrorCudartUnloading' in found_values}}
 
     #: This indicates that a CUDA Runtime API call cannot be executed
     #: because it is being called during process shut down, at a point in
     #: time after CUDA driver has been unloaded.
-    cudaErrorCudartUnloading = ccudart.cudaError.cudaErrorCudartUnloading{{endif}}
+    cudaErrorCudartUnloading = cyruntime.cudaError.cudaErrorCudartUnloading{{endif}}
     {{if 'cudaErrorProfilerDisabled' in found_values}}
 
     #: This indicates profiler is not initialized for this run. This can
     #: happen when the application is running with external profiling tools
     #: like visual profiler.
-    cudaErrorProfilerDisabled = ccudart.cudaError.cudaErrorProfilerDisabled{{endif}}
+    cudaErrorProfilerDisabled = cyruntime.cudaError.cudaErrorProfilerDisabled{{endif}}
     {{if 'cudaErrorProfilerNotInitialized' in found_values}}
 
     #: [Deprecated]
-    cudaErrorProfilerNotInitialized = ccudart.cudaError.cudaErrorProfilerNotInitialized{{endif}}
+    cudaErrorProfilerNotInitialized = cyruntime.cudaError.cudaErrorProfilerNotInitialized{{endif}}
     {{if 'cudaErrorProfilerAlreadyStarted' in found_values}}
 
     #: [Deprecated]
-    cudaErrorProfilerAlreadyStarted = ccudart.cudaError.cudaErrorProfilerAlreadyStarted{{endif}}
+    cudaErrorProfilerAlreadyStarted = cyruntime.cudaError.cudaErrorProfilerAlreadyStarted{{endif}}
     {{if 'cudaErrorProfilerAlreadyStopped' in found_values}}
 
     #: [Deprecated]
-    cudaErrorProfilerAlreadyStopped = ccudart.cudaError.cudaErrorProfilerAlreadyStopped{{endif}}
+    cudaErrorProfilerAlreadyStopped = cyruntime.cudaError.cudaErrorProfilerAlreadyStopped{{endif}}
     {{if 'cudaErrorInvalidConfiguration' in found_values}}
 
     #: This indicates that a kernel launch is requesting resources that can
@@ -352,139 +363,139 @@ class cudaError_t(IntEnum):
     #: memory per block than the device supports will trigger this error,
     #: as will requesting too many threads or blocks. See
     #: :py:obj:`~.cudaDeviceProp` for more device limitations.
-    cudaErrorInvalidConfiguration = ccudart.cudaError.cudaErrorInvalidConfiguration{{endif}}
+    cudaErrorInvalidConfiguration = cyruntime.cudaError.cudaErrorInvalidConfiguration{{endif}}
     {{if 'cudaErrorInvalidPitchValue' in found_values}}
 
     #: This indicates that one or more of the pitch-related parameters
     #: passed to the API call is not within the acceptable range for pitch.
-    cudaErrorInvalidPitchValue = ccudart.cudaError.cudaErrorInvalidPitchValue{{endif}}
+    cudaErrorInvalidPitchValue = cyruntime.cudaError.cudaErrorInvalidPitchValue{{endif}}
     {{if 'cudaErrorInvalidSymbol' in found_values}}
 
     #: This indicates that the symbol name/identifier passed to the API
     #: call is not a valid name or identifier.
-    cudaErrorInvalidSymbol = ccudart.cudaError.cudaErrorInvalidSymbol{{endif}}
+    cudaErrorInvalidSymbol = cyruntime.cudaError.cudaErrorInvalidSymbol{{endif}}
     {{if 'cudaErrorInvalidHostPointer' in found_values}}
 
     #: This indicates that at least one host pointer passed to the API call
     #: is not a valid host pointer. [Deprecated]
-    cudaErrorInvalidHostPointer = ccudart.cudaError.cudaErrorInvalidHostPointer{{endif}}
+    cudaErrorInvalidHostPointer = cyruntime.cudaError.cudaErrorInvalidHostPointer{{endif}}
     {{if 'cudaErrorInvalidDevicePointer' in found_values}}
 
     #: This indicates that at least one device pointer passed to the API
     #: call is not a valid device pointer. [Deprecated]
-    cudaErrorInvalidDevicePointer = ccudart.cudaError.cudaErrorInvalidDevicePointer{{endif}}
+    cudaErrorInvalidDevicePointer = cyruntime.cudaError.cudaErrorInvalidDevicePointer{{endif}}
     {{if 'cudaErrorInvalidTexture' in found_values}}
 
     #: This indicates that the texture passed to the API call is not a
     #: valid texture.
-    cudaErrorInvalidTexture = ccudart.cudaError.cudaErrorInvalidTexture{{endif}}
+    cudaErrorInvalidTexture = cyruntime.cudaError.cudaErrorInvalidTexture{{endif}}
     {{if 'cudaErrorInvalidTextureBinding' in found_values}}
 
     #: This indicates that the texture binding is not valid. This occurs if
     #: you call :py:obj:`~.cudaGetTextureAlignmentOffset()` with an unbound
     #: texture.
-    cudaErrorInvalidTextureBinding = ccudart.cudaError.cudaErrorInvalidTextureBinding{{endif}}
+    cudaErrorInvalidTextureBinding = cyruntime.cudaError.cudaErrorInvalidTextureBinding{{endif}}
     {{if 'cudaErrorInvalidChannelDescriptor' in found_values}}
 
     #: This indicates that the channel descriptor passed to the API call is
     #: not valid. This occurs if the format is not one of the formats
     #: specified by :py:obj:`~.cudaChannelFormatKind`, or if one of the
     #: dimensions is invalid.
-    cudaErrorInvalidChannelDescriptor = ccudart.cudaError.cudaErrorInvalidChannelDescriptor{{endif}}
+    cudaErrorInvalidChannelDescriptor = cyruntime.cudaError.cudaErrorInvalidChannelDescriptor{{endif}}
     {{if 'cudaErrorInvalidMemcpyDirection' in found_values}}
 
     #: This indicates that the direction of the memcpy passed to the API
     #: call is not one of the types specified by
     #: :py:obj:`~.cudaMemcpyKind`.
-    cudaErrorInvalidMemcpyDirection = ccudart.cudaError.cudaErrorInvalidMemcpyDirection{{endif}}
+    cudaErrorInvalidMemcpyDirection = cyruntime.cudaError.cudaErrorInvalidMemcpyDirection{{endif}}
     {{if 'cudaErrorAddressOfConstant' in found_values}}
 
     #: This indicated that the user has taken the address of a constant
     #: variable, which was forbidden up until the CUDA 3.1 release.
     #: [Deprecated]
-    cudaErrorAddressOfConstant = ccudart.cudaError.cudaErrorAddressOfConstant{{endif}}
+    cudaErrorAddressOfConstant = cyruntime.cudaError.cudaErrorAddressOfConstant{{endif}}
     {{if 'cudaErrorTextureFetchFailed' in found_values}}
 
     #: This indicated that a texture fetch was not able to be performed.
     #: This was previously used for device emulation of texture operations.
     #: [Deprecated]
-    cudaErrorTextureFetchFailed = ccudart.cudaError.cudaErrorTextureFetchFailed{{endif}}
+    cudaErrorTextureFetchFailed = cyruntime.cudaError.cudaErrorTextureFetchFailed{{endif}}
     {{if 'cudaErrorTextureNotBound' in found_values}}
 
     #: This indicated that a texture was not bound for access. This was
     #: previously used for device emulation of texture operations.
     #: [Deprecated]
-    cudaErrorTextureNotBound = ccudart.cudaError.cudaErrorTextureNotBound{{endif}}
+    cudaErrorTextureNotBound = cyruntime.cudaError.cudaErrorTextureNotBound{{endif}}
     {{if 'cudaErrorSynchronizationError' in found_values}}
 
     #: This indicated that a synchronization operation had failed. This was
     #: previously used for some device emulation functions. [Deprecated]
-    cudaErrorSynchronizationError = ccudart.cudaError.cudaErrorSynchronizationError{{endif}}
+    cudaErrorSynchronizationError = cyruntime.cudaError.cudaErrorSynchronizationError{{endif}}
     {{if 'cudaErrorInvalidFilterSetting' in found_values}}
 
     #: This indicates that a non-float texture was being accessed with
     #: linear filtering. This is not supported by CUDA.
-    cudaErrorInvalidFilterSetting = ccudart.cudaError.cudaErrorInvalidFilterSetting{{endif}}
+    cudaErrorInvalidFilterSetting = cyruntime.cudaError.cudaErrorInvalidFilterSetting{{endif}}
     {{if 'cudaErrorInvalidNormSetting' in found_values}}
 
     #: This indicates that an attempt was made to read a non-float texture
     #: as a normalized float. This is not supported by CUDA.
-    cudaErrorInvalidNormSetting = ccudart.cudaError.cudaErrorInvalidNormSetting{{endif}}
+    cudaErrorInvalidNormSetting = cyruntime.cudaError.cudaErrorInvalidNormSetting{{endif}}
     {{if 'cudaErrorMixedDeviceExecution' in found_values}}
 
     #: Mixing of device and device emulation code was not allowed.
     #: [Deprecated]
-    cudaErrorMixedDeviceExecution = ccudart.cudaError.cudaErrorMixedDeviceExecution{{endif}}
+    cudaErrorMixedDeviceExecution = cyruntime.cudaError.cudaErrorMixedDeviceExecution{{endif}}
     {{if 'cudaErrorNotYetImplemented' in found_values}}
 
     #: This indicates that the API call is not yet implemented. Production
     #: releases of CUDA will never return this error. [Deprecated]
-    cudaErrorNotYetImplemented = ccudart.cudaError.cudaErrorNotYetImplemented{{endif}}
+    cudaErrorNotYetImplemented = cyruntime.cudaError.cudaErrorNotYetImplemented{{endif}}
     {{if 'cudaErrorMemoryValueTooLarge' in found_values}}
 
     #: This indicated that an emulated device pointer exceeded the 32-bit
     #: address range. [Deprecated]
-    cudaErrorMemoryValueTooLarge = ccudart.cudaError.cudaErrorMemoryValueTooLarge{{endif}}
+    cudaErrorMemoryValueTooLarge = cyruntime.cudaError.cudaErrorMemoryValueTooLarge{{endif}}
     {{if 'cudaErrorStubLibrary' in found_values}}
 
     #: This indicates that the CUDA driver that the application has loaded
     #: is a stub library. Applications that run with the stub rather than a
     #: real driver loaded will result in CUDA API returning this error.
-    cudaErrorStubLibrary = ccudart.cudaError.cudaErrorStubLibrary{{endif}}
+    cudaErrorStubLibrary = cyruntime.cudaError.cudaErrorStubLibrary{{endif}}
     {{if 'cudaErrorInsufficientDriver' in found_values}}
 
     #: This indicates that the installed NVIDIA CUDA driver is older than
     #: the CUDA runtime library. This is not a supported configuration.
     #: Users should install an updated NVIDIA display driver to allow the
     #: application to run.
-    cudaErrorInsufficientDriver = ccudart.cudaError.cudaErrorInsufficientDriver{{endif}}
+    cudaErrorInsufficientDriver = cyruntime.cudaError.cudaErrorInsufficientDriver{{endif}}
     {{if 'cudaErrorCallRequiresNewerDriver' in found_values}}
 
     #: This indicates that the API call requires a newer CUDA driver than
     #: the one currently installed. Users should install an updated NVIDIA
     #: CUDA driver to allow the API call to succeed.
-    cudaErrorCallRequiresNewerDriver = ccudart.cudaError.cudaErrorCallRequiresNewerDriver{{endif}}
+    cudaErrorCallRequiresNewerDriver = cyruntime.cudaError.cudaErrorCallRequiresNewerDriver{{endif}}
     {{if 'cudaErrorInvalidSurface' in found_values}}
 
     #: This indicates that the surface passed to the API call is not a
     #: valid surface.
-    cudaErrorInvalidSurface = ccudart.cudaError.cudaErrorInvalidSurface{{endif}}
+    cudaErrorInvalidSurface = cyruntime.cudaError.cudaErrorInvalidSurface{{endif}}
     {{if 'cudaErrorDuplicateVariableName' in found_values}}
 
     #: This indicates that multiple global or constant variables (across
     #: separate CUDA source files in the application) share the same string
     #: name.
-    cudaErrorDuplicateVariableName = ccudart.cudaError.cudaErrorDuplicateVariableName{{endif}}
+    cudaErrorDuplicateVariableName = cyruntime.cudaError.cudaErrorDuplicateVariableName{{endif}}
     {{if 'cudaErrorDuplicateTextureName' in found_values}}
 
     #: This indicates that multiple textures (across separate CUDA source
     #: files in the application) share the same string name.
-    cudaErrorDuplicateTextureName = ccudart.cudaError.cudaErrorDuplicateTextureName{{endif}}
+    cudaErrorDuplicateTextureName = cyruntime.cudaError.cudaErrorDuplicateTextureName{{endif}}
     {{if 'cudaErrorDuplicateSurfaceName' in found_values}}
 
     #: This indicates that multiple surfaces (across separate CUDA source
     #: files in the application) share the same string name.
-    cudaErrorDuplicateSurfaceName = ccudart.cudaError.cudaErrorDuplicateSurfaceName{{endif}}
+    cudaErrorDuplicateSurfaceName = cyruntime.cudaError.cudaErrorDuplicateSurfaceName{{endif}}
     {{if 'cudaErrorDevicesUnavailable' in found_values}}
 
     #: This indicates that all CUDA devices are busy or unavailable at the
@@ -494,7 +505,7 @@ class cudaError_t(IntEnum):
     #: CUDA kernels have filled up the GPU and are blocking new work from
     #: starting. They can also be unavailable due to memory constraints on
     #: a device that already has active CUDA work being performed.
-    cudaErrorDevicesUnavailable = ccudart.cudaError.cudaErrorDevicesUnavailable{{endif}}
+    cudaErrorDevicesUnavailable = cyruntime.cudaError.cudaErrorDevicesUnavailable{{endif}}
     {{if 'cudaErrorIncompatibleDriverContext' in found_values}}
 
     #: This indicates that the current context is not compatible with this
@@ -506,39 +517,39 @@ class cudaError_t(IntEnum):
     #: context and the Driver context is not primary, or because the Driver
     #: context has been destroyed. Please see :py:obj:`~.Interactions`with
     #: the CUDA Driver API" for more information.
-    cudaErrorIncompatibleDriverContext = ccudart.cudaError.cudaErrorIncompatibleDriverContext{{endif}}
+    cudaErrorIncompatibleDriverContext = cyruntime.cudaError.cudaErrorIncompatibleDriverContext{{endif}}
     {{if 'cudaErrorMissingConfiguration' in found_values}}
 
     #: The device function being invoked (usually via
     #: :py:obj:`~.cudaLaunchKernel()`) was not previously configured via
     #: the :py:obj:`~.cudaConfigureCall()` function.
-    cudaErrorMissingConfiguration = ccudart.cudaError.cudaErrorMissingConfiguration{{endif}}
+    cudaErrorMissingConfiguration = cyruntime.cudaError.cudaErrorMissingConfiguration{{endif}}
     {{if 'cudaErrorPriorLaunchFailure' in found_values}}
 
     #: This indicated that a previous kernel launch failed. This was
     #: previously used for device emulation of kernel launches.
     #: [Deprecated]
-    cudaErrorPriorLaunchFailure = ccudart.cudaError.cudaErrorPriorLaunchFailure{{endif}}
+    cudaErrorPriorLaunchFailure = cyruntime.cudaError.cudaErrorPriorLaunchFailure{{endif}}
     {{if 'cudaErrorLaunchMaxDepthExceeded' in found_values}}
 
     #: This error indicates that a device runtime grid launch did not occur
     #: because the depth of the child grid would exceed the maximum
     #: supported number of nested grid launches.
-    cudaErrorLaunchMaxDepthExceeded = ccudart.cudaError.cudaErrorLaunchMaxDepthExceeded{{endif}}
+    cudaErrorLaunchMaxDepthExceeded = cyruntime.cudaError.cudaErrorLaunchMaxDepthExceeded{{endif}}
     {{if 'cudaErrorLaunchFileScopedTex' in found_values}}
 
     #: This error indicates that a grid launch did not occur because the
     #: kernel uses file-scoped textures which are unsupported by the device
     #: runtime. Kernels launched via the device runtime only support
     #: textures created with the Texture Object API's.
-    cudaErrorLaunchFileScopedTex = ccudart.cudaError.cudaErrorLaunchFileScopedTex{{endif}}
+    cudaErrorLaunchFileScopedTex = cyruntime.cudaError.cudaErrorLaunchFileScopedTex{{endif}}
     {{if 'cudaErrorLaunchFileScopedSurf' in found_values}}
 
     #: This error indicates that a grid launch did not occur because the
     #: kernel uses file-scoped surfaces which are unsupported by the device
     #: runtime. Kernels launched via the device runtime only support
     #: surfaces created with the Surface Object API's.
-    cudaErrorLaunchFileScopedSurf = ccudart.cudaError.cudaErrorLaunchFileScopedSurf{{endif}}
+    cudaErrorLaunchFileScopedSurf = cyruntime.cudaError.cudaErrorLaunchFileScopedSurf{{endif}}
     {{if 'cudaErrorSyncDepthExceeded' in found_values}}
 
     #: This error indicates that a call to
@@ -554,7 +565,7 @@ class cudaError_t(IntEnum):
     #: kernel using the device runtime. Keep in mind that additional levels
     #: of sync depth require the runtime to reserve large amounts of device
     #: memory that cannot be used for user allocations.
-    cudaErrorSyncDepthExceeded = ccudart.cudaError.cudaErrorSyncDepthExceeded{{endif}}
+    cudaErrorSyncDepthExceeded = cyruntime.cudaError.cudaErrorSyncDepthExceeded{{endif}}
     {{if 'cudaErrorLaunchPendingCountExceeded' in found_values}}
 
     #: This error indicates that a device runtime grid launch failed
@@ -566,27 +577,27 @@ class cudaError_t(IntEnum):
     #: be issued to the device runtime. Keep in mind that raising the limit
     #: of pending device runtime launches will require the runtime to
     #: reserve device memory that cannot be used for user allocations.
-    cudaErrorLaunchPendingCountExceeded = ccudart.cudaError.cudaErrorLaunchPendingCountExceeded{{endif}}
+    cudaErrorLaunchPendingCountExceeded = cyruntime.cudaError.cudaErrorLaunchPendingCountExceeded{{endif}}
     {{if 'cudaErrorInvalidDeviceFunction' in found_values}}
 
     #: The requested device function does not exist or is not compiled for
     #: the proper device architecture.
-    cudaErrorInvalidDeviceFunction = ccudart.cudaError.cudaErrorInvalidDeviceFunction{{endif}}
+    cudaErrorInvalidDeviceFunction = cyruntime.cudaError.cudaErrorInvalidDeviceFunction{{endif}}
     {{if 'cudaErrorNoDevice' in found_values}}
 
     #: This indicates that no CUDA-capable devices were detected by the
     #: installed CUDA driver.
-    cudaErrorNoDevice = ccudart.cudaError.cudaErrorNoDevice{{endif}}
+    cudaErrorNoDevice = cyruntime.cudaError.cudaErrorNoDevice{{endif}}
     {{if 'cudaErrorInvalidDevice' in found_values}}
 
     #: This indicates that the device ordinal supplied by the user does not
     #: correspond to a valid CUDA device or that the action requested is
     #: invalid for the specified device.
-    cudaErrorInvalidDevice = ccudart.cudaError.cudaErrorInvalidDevice{{endif}}
+    cudaErrorInvalidDevice = cyruntime.cudaError.cudaErrorInvalidDevice{{endif}}
     {{if 'cudaErrorDeviceNotLicensed' in found_values}}
 
     #: This indicates that the device doesn't have a valid Grid License.
-    cudaErrorDeviceNotLicensed = ccudart.cudaError.cudaErrorDeviceNotLicensed{{endif}}
+    cudaErrorDeviceNotLicensed = cyruntime.cudaError.cudaErrorDeviceNotLicensed{{endif}}
     {{if 'cudaErrorSoftwareValidityNotEstablished' in found_values}}
 
     #: By default, the CUDA runtime may perform a minimal set of self-
@@ -594,15 +605,15 @@ class cudaError_t(IntEnum):
     #: both. Introduced in CUDA 11.2, this error return indicates that at
     #: least one of these tests has failed and the validity of either the
     #: runtime or the driver could not be established.
-    cudaErrorSoftwareValidityNotEstablished = ccudart.cudaError.cudaErrorSoftwareValidityNotEstablished{{endif}}
+    cudaErrorSoftwareValidityNotEstablished = cyruntime.cudaError.cudaErrorSoftwareValidityNotEstablished{{endif}}
     {{if 'cudaErrorStartupFailure' in found_values}}
 
     #: This indicates an internal startup failure in the CUDA runtime.
-    cudaErrorStartupFailure = ccudart.cudaError.cudaErrorStartupFailure{{endif}}
+    cudaErrorStartupFailure = cyruntime.cudaError.cudaErrorStartupFailure{{endif}}
     {{if 'cudaErrorInvalidKernelImage' in found_values}}
 
     #: This indicates that the device kernel image is invalid.
-    cudaErrorInvalidKernelImage = ccudart.cudaError.cudaErrorInvalidKernelImage{{endif}}
+    cudaErrorInvalidKernelImage = cyruntime.cudaError.cudaErrorInvalidKernelImage{{endif}}
     {{if 'cudaErrorDeviceUninitialized' in found_values}}
 
     #: This most frequently indicates that there is no context bound to the
@@ -611,147 +622,147 @@ class cudaError_t(IntEnum):
     #: :py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned
     #: if a user mixes different API versions (i.e. 3010 context with 3020
     #: API calls). See :py:obj:`~.cuCtxGetApiVersion()` for more details.
-    cudaErrorDeviceUninitialized = ccudart.cudaError.cudaErrorDeviceUninitialized{{endif}}
+    cudaErrorDeviceUninitialized = cyruntime.cudaError.cudaErrorDeviceUninitialized{{endif}}
     {{if 'cudaErrorMapBufferObjectFailed' in found_values}}
 
     #: This indicates that the buffer object could not be mapped.
-    cudaErrorMapBufferObjectFailed = ccudart.cudaError.cudaErrorMapBufferObjectFailed{{endif}}
+    cudaErrorMapBufferObjectFailed = cyruntime.cudaError.cudaErrorMapBufferObjectFailed{{endif}}
     {{if 'cudaErrorUnmapBufferObjectFailed' in found_values}}
 
     #: This indicates that the buffer object could not be unmapped.
-    cudaErrorUnmapBufferObjectFailed = ccudart.cudaError.cudaErrorUnmapBufferObjectFailed{{endif}}
+    cudaErrorUnmapBufferObjectFailed = cyruntime.cudaError.cudaErrorUnmapBufferObjectFailed{{endif}}
     {{if 'cudaErrorArrayIsMapped' in found_values}}
 
     #: This indicates that the specified array is currently mapped and thus
     #: cannot be destroyed.
-    cudaErrorArrayIsMapped = ccudart.cudaError.cudaErrorArrayIsMapped{{endif}}
+    cudaErrorArrayIsMapped = cyruntime.cudaError.cudaErrorArrayIsMapped{{endif}}
     {{if 'cudaErrorAlreadyMapped' in found_values}}
 
     #: This indicates that the resource is already mapped.
-    cudaErrorAlreadyMapped = ccudart.cudaError.cudaErrorAlreadyMapped{{endif}}
+    cudaErrorAlreadyMapped = cyruntime.cudaError.cudaErrorAlreadyMapped{{endif}}
     {{if 'cudaErrorNoKernelImageForDevice' in found_values}}
 
     #: This indicates that there is no kernel image available that is
     #: suitable for the device. This can occur when a user specifies code
     #: generation options for a particular CUDA source file that do not
     #: include the corresponding device configuration.
-    cudaErrorNoKernelImageForDevice = ccudart.cudaError.cudaErrorNoKernelImageForDevice{{endif}}
+    cudaErrorNoKernelImageForDevice = cyruntime.cudaError.cudaErrorNoKernelImageForDevice{{endif}}
     {{if 'cudaErrorAlreadyAcquired' in found_values}}
 
     #: This indicates that a resource has already been acquired.
-    cudaErrorAlreadyAcquired = ccudart.cudaError.cudaErrorAlreadyAcquired{{endif}}
+    cudaErrorAlreadyAcquired = cyruntime.cudaError.cudaErrorAlreadyAcquired{{endif}}
     {{if 'cudaErrorNotMapped' in found_values}}
 
     #: This indicates that a resource is not mapped.
-    cudaErrorNotMapped = ccudart.cudaError.cudaErrorNotMapped{{endif}}
+    cudaErrorNotMapped = cyruntime.cudaError.cudaErrorNotMapped{{endif}}
     {{if 'cudaErrorNotMappedAsArray' in found_values}}
 
     #: This indicates that a mapped resource is not available for access as
     #: an array.
-    cudaErrorNotMappedAsArray = ccudart.cudaError.cudaErrorNotMappedAsArray{{endif}}
+    cudaErrorNotMappedAsArray = cyruntime.cudaError.cudaErrorNotMappedAsArray{{endif}}
     {{if 'cudaErrorNotMappedAsPointer' in found_values}}
 
     #: This indicates that a mapped resource is not available for access as
     #: a pointer.
-    cudaErrorNotMappedAsPointer = ccudart.cudaError.cudaErrorNotMappedAsPointer{{endif}}
+    cudaErrorNotMappedAsPointer = cyruntime.cudaError.cudaErrorNotMappedAsPointer{{endif}}
     {{if 'cudaErrorECCUncorrectable' in found_values}}
 
     #: This indicates that an uncorrectable ECC error was detected during
     #: execution.
-    cudaErrorECCUncorrectable = ccudart.cudaError.cudaErrorECCUncorrectable{{endif}}
+    cudaErrorECCUncorrectable = cyruntime.cudaError.cudaErrorECCUncorrectable{{endif}}
     {{if 'cudaErrorUnsupportedLimit' in found_values}}
 
     #: This indicates that the :py:obj:`~.cudaLimit` passed to the API call
     #: is not supported by the active device.
-    cudaErrorUnsupportedLimit = ccudart.cudaError.cudaErrorUnsupportedLimit{{endif}}
+    cudaErrorUnsupportedLimit = cyruntime.cudaError.cudaErrorUnsupportedLimit{{endif}}
     {{if 'cudaErrorDeviceAlreadyInUse' in found_values}}
 
     #: This indicates that a call tried to access an exclusive-thread
     #: device that is already in use by a different thread.
-    cudaErrorDeviceAlreadyInUse = ccudart.cudaError.cudaErrorDeviceAlreadyInUse{{endif}}
+    cudaErrorDeviceAlreadyInUse = cyruntime.cudaError.cudaErrorDeviceAlreadyInUse{{endif}}
     {{if 'cudaErrorPeerAccessUnsupported' in found_values}}
 
     #: This error indicates that P2P access is not supported across the
     #: given devices.
-    cudaErrorPeerAccessUnsupported = ccudart.cudaError.cudaErrorPeerAccessUnsupported{{endif}}
+    cudaErrorPeerAccessUnsupported = cyruntime.cudaError.cudaErrorPeerAccessUnsupported{{endif}}
     {{if 'cudaErrorInvalidPtx' in found_values}}
 
     #: A PTX compilation failed. The runtime may fall back to compiling PTX
     #: if an application does not contain a suitable binary for the current
     #: device.
-    cudaErrorInvalidPtx = ccudart.cudaError.cudaErrorInvalidPtx{{endif}}
+    cudaErrorInvalidPtx = cyruntime.cudaError.cudaErrorInvalidPtx{{endif}}
     {{if 'cudaErrorInvalidGraphicsContext' in found_values}}
 
     #: This indicates an error with the OpenGL or DirectX context.
-    cudaErrorInvalidGraphicsContext = ccudart.cudaError.cudaErrorInvalidGraphicsContext{{endif}}
+    cudaErrorInvalidGraphicsContext = cyruntime.cudaError.cudaErrorInvalidGraphicsContext{{endif}}
     {{if 'cudaErrorNvlinkUncorrectable' in found_values}}
 
     #: This indicates that an uncorrectable NVLink error was detected
     #: during the execution.
-    cudaErrorNvlinkUncorrectable = ccudart.cudaError.cudaErrorNvlinkUncorrectable{{endif}}
+    cudaErrorNvlinkUncorrectable = cyruntime.cudaError.cudaErrorNvlinkUncorrectable{{endif}}
     {{if 'cudaErrorJitCompilerNotFound' in found_values}}
 
     #: This indicates that the PTX JIT compiler library was not found. The
     #: JIT Compiler library is used for PTX compilation. The runtime may
     #: fall back to compiling PTX if an application does not contain a
     #: suitable binary for the current device.
-    cudaErrorJitCompilerNotFound = ccudart.cudaError.cudaErrorJitCompilerNotFound{{endif}}
+    cudaErrorJitCompilerNotFound = cyruntime.cudaError.cudaErrorJitCompilerNotFound{{endif}}
     {{if 'cudaErrorUnsupportedPtxVersion' in found_values}}
 
     #: This indicates that the provided PTX was compiled with an
     #: unsupported toolchain. The most common reason for this, is the PTX
     #: was generated by a compiler newer than what is supported by the CUDA
     #: driver and PTX JIT compiler.
-    cudaErrorUnsupportedPtxVersion = ccudart.cudaError.cudaErrorUnsupportedPtxVersion{{endif}}
+    cudaErrorUnsupportedPtxVersion = cyruntime.cudaError.cudaErrorUnsupportedPtxVersion{{endif}}
     {{if 'cudaErrorJitCompilationDisabled' in found_values}}
 
     #: This indicates that the JIT compilation was disabled. The JIT
     #: compilation compiles PTX. The runtime may fall back to compiling PTX
     #: if an application does not contain a suitable binary for the current
     #: device.
-    cudaErrorJitCompilationDisabled = ccudart.cudaError.cudaErrorJitCompilationDisabled{{endif}}
+    cudaErrorJitCompilationDisabled = cyruntime.cudaError.cudaErrorJitCompilationDisabled{{endif}}
     {{if 'cudaErrorUnsupportedExecAffinity' in found_values}}
 
     #: This indicates that the provided execution affinity is not supported
     #: by the device.
-    cudaErrorUnsupportedExecAffinity = ccudart.cudaError.cudaErrorUnsupportedExecAffinity{{endif}}
+    cudaErrorUnsupportedExecAffinity = cyruntime.cudaError.cudaErrorUnsupportedExecAffinity{{endif}}
     {{if 'cudaErrorInvalidSource' in found_values}}
 
     #: This indicates that the device kernel source is invalid.
-    cudaErrorInvalidSource = ccudart.cudaError.cudaErrorInvalidSource{{endif}}
+    cudaErrorInvalidSource = cyruntime.cudaError.cudaErrorInvalidSource{{endif}}
     {{if 'cudaErrorFileNotFound' in found_values}}
 
     #: This indicates that the file specified was not found.
-    cudaErrorFileNotFound = ccudart.cudaError.cudaErrorFileNotFound{{endif}}
+    cudaErrorFileNotFound = cyruntime.cudaError.cudaErrorFileNotFound{{endif}}
     {{if 'cudaErrorSharedObjectSymbolNotFound' in found_values}}
 
     #: This indicates that a link to a shared object failed to resolve.
-    cudaErrorSharedObjectSymbolNotFound = ccudart.cudaError.cudaErrorSharedObjectSymbolNotFound{{endif}}
+    cudaErrorSharedObjectSymbolNotFound = cyruntime.cudaError.cudaErrorSharedObjectSymbolNotFound{{endif}}
     {{if 'cudaErrorSharedObjectInitFailed' in found_values}}
 
     #: This indicates that initialization of a shared object failed.
-    cudaErrorSharedObjectInitFailed = ccudart.cudaError.cudaErrorSharedObjectInitFailed{{endif}}
+    cudaErrorSharedObjectInitFailed = cyruntime.cudaError.cudaErrorSharedObjectInitFailed{{endif}}
     {{if 'cudaErrorOperatingSystem' in found_values}}
 
     #: This error indicates that an OS call failed.
-    cudaErrorOperatingSystem = ccudart.cudaError.cudaErrorOperatingSystem{{endif}}
+    cudaErrorOperatingSystem = cyruntime.cudaError.cudaErrorOperatingSystem{{endif}}
     {{if 'cudaErrorInvalidResourceHandle' in found_values}}
 
     #: This indicates that a resource handle passed to the API call was not
     #: valid. Resource handles are opaque types like
     #: :py:obj:`~.cudaStream_t` and :py:obj:`~.cudaEvent_t`.
-    cudaErrorInvalidResourceHandle = ccudart.cudaError.cudaErrorInvalidResourceHandle{{endif}}
+    cudaErrorInvalidResourceHandle = cyruntime.cudaError.cudaErrorInvalidResourceHandle{{endif}}
     {{if 'cudaErrorIllegalState' in found_values}}
 
     #: This indicates that a resource required by the API call is not in a
     #: valid state to perform the requested operation.
-    cudaErrorIllegalState = ccudart.cudaError.cudaErrorIllegalState{{endif}}
+    cudaErrorIllegalState = cyruntime.cudaError.cudaErrorIllegalState{{endif}}
     {{if 'cudaErrorSymbolNotFound' in found_values}}
 
     #: This indicates that a named symbol was not found. Examples of
     #: symbols are global/constant variable names, driver function names,
     #: texture names, and surface names.
-    cudaErrorSymbolNotFound = ccudart.cudaError.cudaErrorSymbolNotFound{{endif}}
+    cudaErrorSymbolNotFound = cyruntime.cudaError.cudaErrorSymbolNotFound{{endif}}
     {{if 'cudaErrorNotReady' in found_values}}
 
     #: This indicates that asynchronous operations issued previously have
@@ -759,14 +770,14 @@ class cudaError_t(IntEnum):
     #: indicated differently than :py:obj:`~.cudaSuccess` (which indicates
     #: completion). Calls that may return this value include
     #: :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`.
-    cudaErrorNotReady = ccudart.cudaError.cudaErrorNotReady{{endif}}
+    cudaErrorNotReady = cyruntime.cudaError.cudaErrorNotReady{{endif}}
     {{if 'cudaErrorIllegalAddress' in found_values}}
 
     #: The device encountered a load or store instruction on an invalid
     #: memory address. This leaves the process in an inconsistent state and
     #: any further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    cudaErrorIllegalAddress = ccudart.cudaError.cudaErrorIllegalAddress{{endif}}
+    cudaErrorIllegalAddress = cyruntime.cudaError.cudaErrorIllegalAddress{{endif}}
     {{if 'cudaErrorLaunchOutOfResources' in found_values}}
 
     #: This indicates that a launch did not occur because it did not have
@@ -775,7 +786,7 @@ class cudaError_t(IntEnum):
     #: indicates that the user has attempted to pass too many arguments to
     #: the device kernel, or the kernel launch specifies too many threads
     #: for the kernel's register count.
-    cudaErrorLaunchOutOfResources = ccudart.cudaError.cudaErrorLaunchOutOfResources{{endif}}
+    cudaErrorLaunchOutOfResources = cyruntime.cudaError.cudaErrorLaunchOutOfResources{{endif}}
     {{if 'cudaErrorLaunchTimeout' in found_values}}
 
     #: This indicates that the device kernel took too long to execute. This
@@ -784,25 +795,25 @@ class cudaError_t(IntEnum):
     #: leaves the process in an inconsistent state and any further CUDA
     #: work will return the same error. To continue using CUDA, the process
     #: must be terminated and relaunched.
-    cudaErrorLaunchTimeout = ccudart.cudaError.cudaErrorLaunchTimeout{{endif}}
+    cudaErrorLaunchTimeout = cyruntime.cudaError.cudaErrorLaunchTimeout{{endif}}
     {{if 'cudaErrorLaunchIncompatibleTexturing' in found_values}}
 
     #: This error indicates a kernel launch that uses an incompatible
     #: texturing mode.
-    cudaErrorLaunchIncompatibleTexturing = ccudart.cudaError.cudaErrorLaunchIncompatibleTexturing{{endif}}
+    cudaErrorLaunchIncompatibleTexturing = cyruntime.cudaError.cudaErrorLaunchIncompatibleTexturing{{endif}}
     {{if 'cudaErrorPeerAccessAlreadyEnabled' in found_values}}
 
     #: This error indicates that a call to
     #: :py:obj:`~.cudaDeviceEnablePeerAccess()` is trying to re-enable peer
     #: addressing on from a context which has already had peer addressing
     #: enabled.
-    cudaErrorPeerAccessAlreadyEnabled = ccudart.cudaError.cudaErrorPeerAccessAlreadyEnabled{{endif}}
+    cudaErrorPeerAccessAlreadyEnabled = cyruntime.cudaError.cudaErrorPeerAccessAlreadyEnabled{{endif}}
     {{if 'cudaErrorPeerAccessNotEnabled' in found_values}}
 
     #: This error indicates that :py:obj:`~.cudaDeviceDisablePeerAccess()`
     #: is trying to disable peer addressing which has not been enabled yet
     #: via :py:obj:`~.cudaDeviceEnablePeerAccess()`.
-    cudaErrorPeerAccessNotEnabled = ccudart.cudaError.cudaErrorPeerAccessNotEnabled{{endif}}
+    cudaErrorPeerAccessNotEnabled = cyruntime.cudaError.cudaErrorPeerAccessNotEnabled{{endif}}
     {{if 'cudaErrorSetOnActiveProcess' in found_values}}
 
     #: This indicates that the user has called
@@ -816,37 +827,37 @@ class cudaError_t(IntEnum):
     #: operations). This error can also be returned if using runtime/driver
     #: interoperability and there is an existing :py:obj:`~.CUcontext`
     #: active on the host thread.
-    cudaErrorSetOnActiveProcess = ccudart.cudaError.cudaErrorSetOnActiveProcess{{endif}}
+    cudaErrorSetOnActiveProcess = cyruntime.cudaError.cudaErrorSetOnActiveProcess{{endif}}
     {{if 'cudaErrorContextIsDestroyed' in found_values}}
 
     #: This error indicates that the context current to the calling thread
     #: has been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary
     #: context which has not yet been initialized.
-    cudaErrorContextIsDestroyed = ccudart.cudaError.cudaErrorContextIsDestroyed{{endif}}
+    cudaErrorContextIsDestroyed = cyruntime.cudaError.cudaErrorContextIsDestroyed{{endif}}
     {{if 'cudaErrorAssert' in found_values}}
 
     #: An assert triggered in device code during kernel execution. The
     #: device cannot be used again. All existing allocations are invalid.
     #: To continue using CUDA, the process must be terminated and
     #: relaunched.
-    cudaErrorAssert = ccudart.cudaError.cudaErrorAssert{{endif}}
+    cudaErrorAssert = cyruntime.cudaError.cudaErrorAssert{{endif}}
     {{if 'cudaErrorTooManyPeers' in found_values}}
 
     #: This error indicates that the hardware resources required to enable
     #: peer access have been exhausted for one or more of the devices
     #: passed to :py:obj:`~.cudaEnablePeerAccess()`.
-    cudaErrorTooManyPeers = ccudart.cudaError.cudaErrorTooManyPeers{{endif}}
+    cudaErrorTooManyPeers = cyruntime.cudaError.cudaErrorTooManyPeers{{endif}}
     {{if 'cudaErrorHostMemoryAlreadyRegistered' in found_values}}
 
     #: This error indicates that the memory range passed to
     #: :py:obj:`~.cudaHostRegister()` has already been registered.
-    cudaErrorHostMemoryAlreadyRegistered = ccudart.cudaError.cudaErrorHostMemoryAlreadyRegistered{{endif}}
+    cudaErrorHostMemoryAlreadyRegistered = cyruntime.cudaError.cudaErrorHostMemoryAlreadyRegistered{{endif}}
     {{if 'cudaErrorHostMemoryNotRegistered' in found_values}}
 
     #: This error indicates that the pointer passed to
     #: :py:obj:`~.cudaHostUnregister()` does not correspond to any
     #: currently registered memory region.
-    cudaErrorHostMemoryNotRegistered = ccudart.cudaError.cudaErrorHostMemoryNotRegistered{{endif}}
+    cudaErrorHostMemoryNotRegistered = cyruntime.cudaError.cudaErrorHostMemoryNotRegistered{{endif}}
     {{if 'cudaErrorHardwareStackError' in found_values}}
 
     #: Device encountered an error in the call stack during kernel
@@ -854,14 +865,14 @@ class cudaError_t(IntEnum):
     #: size limit. This leaves the process in an inconsistent state and any
     #: further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    cudaErrorHardwareStackError = ccudart.cudaError.cudaErrorHardwareStackError{{endif}}
+    cudaErrorHardwareStackError = cyruntime.cudaError.cudaErrorHardwareStackError{{endif}}
     {{if 'cudaErrorIllegalInstruction' in found_values}}
 
     #: The device encountered an illegal instruction during kernel
     #: execution This leaves the process in an inconsistent state and any
     #: further CUDA work will return the same error. To continue using
     #: CUDA, the process must be terminated and relaunched.
-    cudaErrorIllegalInstruction = ccudart.cudaError.cudaErrorIllegalInstruction{{endif}}
+    cudaErrorIllegalInstruction = cyruntime.cudaError.cudaErrorIllegalInstruction{{endif}}
     {{if 'cudaErrorMisalignedAddress' in found_values}}
 
     #: The device encountered a load or store instruction on a memory
@@ -869,7 +880,7 @@ class cudaError_t(IntEnum):
     #: inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    cudaErrorMisalignedAddress = ccudart.cudaError.cudaErrorMisalignedAddress{{endif}}
+    cudaErrorMisalignedAddress = cyruntime.cudaError.cudaErrorMisalignedAddress{{endif}}
     {{if 'cudaErrorInvalidAddressSpace' in found_values}}
 
     #: While executing a kernel, the device encountered an instruction
@@ -879,14 +890,14 @@ class cudaError_t(IntEnum):
     #: inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    cudaErrorInvalidAddressSpace = ccudart.cudaError.cudaErrorInvalidAddressSpace{{endif}}
+    cudaErrorInvalidAddressSpace = cyruntime.cudaError.cudaErrorInvalidAddressSpace{{endif}}
     {{if 'cudaErrorInvalidPc' in found_values}}
 
     #: The device encountered an invalid program counter. This leaves the
     #: process in an inconsistent state and any further CUDA work will
     #: return the same error. To continue using CUDA, the process must be
     #: terminated and relaunched.
-    cudaErrorInvalidPc = ccudart.cudaError.cudaErrorInvalidPc{{endif}}
+    cudaErrorInvalidPc = cyruntime.cudaError.cudaErrorInvalidPc{{endif}}
     {{if 'cudaErrorLaunchFailure' in found_values}}
 
     #: An exception occurred on the device while executing a kernel. Common
@@ -897,7 +908,7 @@ class cudaError_t(IntEnum):
     #: inconsistent state and any further CUDA work will return the same
     #: error. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    cudaErrorLaunchFailure = ccudart.cudaError.cudaErrorLaunchFailure{{endif}}
+    cudaErrorLaunchFailure = cyruntime.cudaError.cudaErrorLaunchFailure{{endif}}
     {{if 'cudaErrorCooperativeLaunchTooLarge' in found_values}}
 
     #: This error indicates that the number of blocks launched per grid for
@@ -909,16 +920,16 @@ class cudaError_t(IntEnum):
     #: :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`
     #: times the number of multiprocessors as specified by the device
     #: attribute :py:obj:`~.cudaDevAttrMultiProcessorCount`.
-    cudaErrorCooperativeLaunchTooLarge = ccudart.cudaError.cudaErrorCooperativeLaunchTooLarge{{endif}}
+    cudaErrorCooperativeLaunchTooLarge = cyruntime.cudaError.cudaErrorCooperativeLaunchTooLarge{{endif}}
     {{if 'cudaErrorNotPermitted' in found_values}}
 
     #: This error indicates the attempted operation is not permitted.
-    cudaErrorNotPermitted = ccudart.cudaError.cudaErrorNotPermitted{{endif}}
+    cudaErrorNotPermitted = cyruntime.cudaError.cudaErrorNotPermitted{{endif}}
     {{if 'cudaErrorNotSupported' in found_values}}
 
     #: This error indicates the attempted operation is not supported on the
     #: current system or device.
-    cudaErrorNotSupported = ccudart.cudaError.cudaErrorNotSupported{{endif}}
+    cudaErrorNotSupported = cyruntime.cudaError.cudaErrorNotSupported{{endif}}
     {{if 'cudaErrorSystemNotReady' in found_values}}
 
     #: This error indicates that the system is not yet ready to start any
@@ -926,13 +937,13 @@ class cudaError_t(IntEnum):
     #: is in a valid state and all required driver daemons are actively
     #: running. More information about this error can be found in the
     #: system specific user guide.
-    cudaErrorSystemNotReady = ccudart.cudaError.cudaErrorSystemNotReady{{endif}}
+    cudaErrorSystemNotReady = cyruntime.cudaError.cudaErrorSystemNotReady{{endif}}
     {{if 'cudaErrorSystemDriverMismatch' in found_values}}
 
     #: This error indicates that there is a mismatch between the versions
     #: of the display driver and the CUDA driver. Refer to the
     #: compatibility documentation for supported versions.
-    cudaErrorSystemDriverMismatch = ccudart.cudaError.cudaErrorSystemDriverMismatch{{endif}}
+    cudaErrorSystemDriverMismatch = cyruntime.cudaError.cudaErrorSystemDriverMismatch{{endif}}
     {{if 'cudaErrorCompatNotSupportedOnDevice' in found_values}}
 
     #: This error indicates that the system was upgraded to run with
@@ -941,95 +952,95 @@ class cudaError_t(IntEnum):
     #: documentation for the supported hardware matrix or ensure that only
     #: supported hardware is visible during initialization via the
     #: CUDA_VISIBLE_DEVICES environment variable.
-    cudaErrorCompatNotSupportedOnDevice = ccudart.cudaError.cudaErrorCompatNotSupportedOnDevice{{endif}}
+    cudaErrorCompatNotSupportedOnDevice = cyruntime.cudaError.cudaErrorCompatNotSupportedOnDevice{{endif}}
     {{if 'cudaErrorMpsConnectionFailed' in found_values}}
 
     #: This error indicates that the MPS client failed to connect to the
     #: MPS control daemon or the MPS server.
-    cudaErrorMpsConnectionFailed = ccudart.cudaError.cudaErrorMpsConnectionFailed{{endif}}
+    cudaErrorMpsConnectionFailed = cyruntime.cudaError.cudaErrorMpsConnectionFailed{{endif}}
     {{if 'cudaErrorMpsRpcFailure' in found_values}}
 
     #: This error indicates that the remote procedural call between the MPS
     #: server and the MPS client failed.
-    cudaErrorMpsRpcFailure = ccudart.cudaError.cudaErrorMpsRpcFailure{{endif}}
+    cudaErrorMpsRpcFailure = cyruntime.cudaError.cudaErrorMpsRpcFailure{{endif}}
     {{if 'cudaErrorMpsServerNotReady' in found_values}}
 
     #: This error indicates that the MPS server is not ready to accept new
     #: MPS client requests. This error can be returned when the MPS server
     #: is in the process of recovering from a fatal failure.
-    cudaErrorMpsServerNotReady = ccudart.cudaError.cudaErrorMpsServerNotReady{{endif}}
+    cudaErrorMpsServerNotReady = cyruntime.cudaError.cudaErrorMpsServerNotReady{{endif}}
     {{if 'cudaErrorMpsMaxClientsReached' in found_values}}
 
     #: This error indicates that the hardware resources required to create
     #: MPS client have been exhausted.
-    cudaErrorMpsMaxClientsReached = ccudart.cudaError.cudaErrorMpsMaxClientsReached{{endif}}
+    cudaErrorMpsMaxClientsReached = cyruntime.cudaError.cudaErrorMpsMaxClientsReached{{endif}}
     {{if 'cudaErrorMpsMaxConnectionsReached' in found_values}}
 
     #: This error indicates the the hardware resources required to device
     #: connections have been exhausted.
-    cudaErrorMpsMaxConnectionsReached = ccudart.cudaError.cudaErrorMpsMaxConnectionsReached{{endif}}
+    cudaErrorMpsMaxConnectionsReached = cyruntime.cudaError.cudaErrorMpsMaxConnectionsReached{{endif}}
     {{if 'cudaErrorMpsClientTerminated' in found_values}}
 
     #: This error indicates that the MPS client has been terminated by the
     #: server. To continue using CUDA, the process must be terminated and
     #: relaunched.
-    cudaErrorMpsClientTerminated = ccudart.cudaError.cudaErrorMpsClientTerminated{{endif}}
+    cudaErrorMpsClientTerminated = cyruntime.cudaError.cudaErrorMpsClientTerminated{{endif}}
     {{if 'cudaErrorStreamCaptureUnsupported' in found_values}}
 
     #: The operation is not permitted when the stream is capturing.
-    cudaErrorStreamCaptureUnsupported = ccudart.cudaError.cudaErrorStreamCaptureUnsupported{{endif}}
+    cudaErrorStreamCaptureUnsupported = cyruntime.cudaError.cudaErrorStreamCaptureUnsupported{{endif}}
     {{if 'cudaErrorStreamCaptureInvalidated' in found_values}}
 
     #: The current capture sequence on the stream has been invalidated due
     #: to a previous error.
-    cudaErrorStreamCaptureInvalidated = ccudart.cudaError.cudaErrorStreamCaptureInvalidated{{endif}}
+    cudaErrorStreamCaptureInvalidated = cyruntime.cudaError.cudaErrorStreamCaptureInvalidated{{endif}}
     {{if 'cudaErrorStreamCaptureMerge' in found_values}}
 
     #: The operation would have resulted in a merge of two independent
     #: capture sequences.
-    cudaErrorStreamCaptureMerge = ccudart.cudaError.cudaErrorStreamCaptureMerge{{endif}}
+    cudaErrorStreamCaptureMerge = cyruntime.cudaError.cudaErrorStreamCaptureMerge{{endif}}
     {{if 'cudaErrorStreamCaptureUnmatched' in found_values}}
 
     #: The capture was not initiated in this stream.
-    cudaErrorStreamCaptureUnmatched = ccudart.cudaError.cudaErrorStreamCaptureUnmatched{{endif}}
+    cudaErrorStreamCaptureUnmatched = cyruntime.cudaError.cudaErrorStreamCaptureUnmatched{{endif}}
     {{if 'cudaErrorStreamCaptureUnjoined' in found_values}}
 
     #: The capture sequence contains a fork that was not joined to the
     #: primary stream.
-    cudaErrorStreamCaptureUnjoined = ccudart.cudaError.cudaErrorStreamCaptureUnjoined{{endif}}
+    cudaErrorStreamCaptureUnjoined = cyruntime.cudaError.cudaErrorStreamCaptureUnjoined{{endif}}
     {{if 'cudaErrorStreamCaptureIsolation' in found_values}}
 
     #: A dependency would have been created which crosses the capture
     #: sequence boundary. Only implicit in-stream ordering dependencies are
     #: allowed to cross the boundary.
-    cudaErrorStreamCaptureIsolation = ccudart.cudaError.cudaErrorStreamCaptureIsolation{{endif}}
+    cudaErrorStreamCaptureIsolation = cyruntime.cudaError.cudaErrorStreamCaptureIsolation{{endif}}
     {{if 'cudaErrorStreamCaptureImplicit' in found_values}}
 
     #: The operation would have resulted in a disallowed implicit
     #: dependency on a current capture sequence from cudaStreamLegacy.
-    cudaErrorStreamCaptureImplicit = ccudart.cudaError.cudaErrorStreamCaptureImplicit{{endif}}
+    cudaErrorStreamCaptureImplicit = cyruntime.cudaError.cudaErrorStreamCaptureImplicit{{endif}}
     {{if 'cudaErrorCapturedEvent' in found_values}}
 
     #: The operation is not permitted on an event which was last recorded
     #: in a capturing stream.
-    cudaErrorCapturedEvent = ccudart.cudaError.cudaErrorCapturedEvent{{endif}}
+    cudaErrorCapturedEvent = cyruntime.cudaError.cudaErrorCapturedEvent{{endif}}
     {{if 'cudaErrorStreamCaptureWrongThread' in found_values}}
 
     #: A stream capture sequence not initiated with the
     #: :py:obj:`~.cudaStreamCaptureModeRelaxed` argument to
     #: :py:obj:`~.cudaStreamBeginCapture` was passed to
     #: :py:obj:`~.cudaStreamEndCapture` in a different thread.
-    cudaErrorStreamCaptureWrongThread = ccudart.cudaError.cudaErrorStreamCaptureWrongThread{{endif}}
+    cudaErrorStreamCaptureWrongThread = cyruntime.cudaError.cudaErrorStreamCaptureWrongThread{{endif}}
     {{if 'cudaErrorTimeout' in found_values}}
 
     #: This indicates that the wait operation has timed out.
-    cudaErrorTimeout = ccudart.cudaError.cudaErrorTimeout{{endif}}
+    cudaErrorTimeout = cyruntime.cudaError.cudaErrorTimeout{{endif}}
     {{if 'cudaErrorGraphExecUpdateFailure' in found_values}}
 
     #: This error indicates that the graph update was not performed because
     #: it included changes which violated constraints specific to
     #: instantiated graph update.
-    cudaErrorGraphExecUpdateFailure = ccudart.cudaError.cudaErrorGraphExecUpdateFailure{{endif}}
+    cudaErrorGraphExecUpdateFailure = cyruntime.cudaError.cudaErrorGraphExecUpdateFailure{{endif}}
     {{if 'cudaErrorExternalDevice' in found_values}}
 
     #: This indicates that an async error has occurred in a device outside
@@ -1039,2740 +1050,2842 @@ class cudaError_t(IntEnum):
     #: the process in an inconsistent state and any further CUDA work will
     #: return the same error. To continue using CUDA, the process must be
     #: terminated and relaunched.
-    cudaErrorExternalDevice = ccudart.cudaError.cudaErrorExternalDevice{{endif}}
+    cudaErrorExternalDevice = cyruntime.cudaError.cudaErrorExternalDevice{{endif}}
     {{if 'cudaErrorInvalidClusterSize' in found_values}}
 
     #: This indicates that a kernel launch error has occurred due to
     #: cluster misconfiguration.
-    cudaErrorInvalidClusterSize = ccudart.cudaError.cudaErrorInvalidClusterSize{{endif}}
+    cudaErrorInvalidClusterSize = cyruntime.cudaError.cudaErrorInvalidClusterSize{{endif}}
     {{if 'cudaErrorUnknown' in found_values}}
 
     #: This indicates that an unknown internal error has occurred.
-    cudaErrorUnknown = ccudart.cudaError.cudaErrorUnknown{{endif}}
+    cudaErrorUnknown = cyruntime.cudaError.cudaErrorUnknown{{endif}}
     {{if 'cudaErrorApiFailureBase' in found_values}}
 
     #: Any unhandled CUDA driver error is added to this value and returned
     #: via the runtime. Production releases of CUDA should not return such
     #: errors. [Deprecated]
-    cudaErrorApiFailureBase = ccudart.cudaError.cudaErrorApiFailureBase{{endif}}
+    cudaErrorApiFailureBase = cyruntime.cudaError.cudaErrorApiFailureBase{{endif}}
 {{endif}}
-{{if 'cudaChannelFormatKind' in found_types}}
+{{if 'cudaOutputMode' in found_types}}
 
-class cudaChannelFormatKind(IntEnum):
+class cudaOutputMode_t(IntEnum):
     """
-    Channel format kind
+    CUDA Profiler Output modes
     """
-    {{if 'cudaChannelFormatKindSigned' in found_values}}
+    {{if 'cudaKeyValuePair' in found_values}}
 
-    #: Signed channel format
-    cudaChannelFormatKindSigned = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSigned{{endif}}
-    {{if 'cudaChannelFormatKindUnsigned' in found_values}}
+    #: Output mode Key-Value pair format.
+    cudaKeyValuePair = cyruntime.cudaOutputMode.cudaKeyValuePair{{endif}}
+    {{if 'cudaCSV' in found_values}}
 
-    #: Unsigned channel format
-    cudaChannelFormatKindUnsigned = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsigned{{endif}}
-    {{if 'cudaChannelFormatKindFloat' in found_values}}
+    #: Output mode Comma separated values format.
+    cudaCSV = cyruntime.cudaOutputMode.cudaCSV{{endif}}
+{{endif}}
+{{if 'cudaLaunchAttributeID' in found_types}}
 
-    #: Float channel format
-    cudaChannelFormatKindFloat = ccudart.cudaChannelFormatKind.cudaChannelFormatKindFloat{{endif}}
-    {{if 'cudaChannelFormatKindNone' in found_values}}
+class cudaLaunchAttributeID(IntEnum):
+    """
+    Launch attributes enum; used as id field of
+    :py:obj:`~.cudaLaunchAttribute`
+    """
+    {{if 'cudaLaunchAttributeIgnore' in found_values}}
 
-    #: No channel format
-    cudaChannelFormatKindNone = ccudart.cudaChannelFormatKind.cudaChannelFormatKindNone{{endif}}
-    {{if 'cudaChannelFormatKindNV12' in found_values}}
+    #: Ignored entry, for convenient composition
+    cudaLaunchAttributeIgnore = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore{{endif}}
+    {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}}
 
-    #: Unsigned 8-bit integers, planar 4:2:0 YUV format
-    cudaChannelFormatKindNV12 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindNV12{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized8X1' in found_values}}
+    #: Valid for streams, graph nodes, launches.
+    cudaLaunchAttributeAccessPolicyWindow = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow{{endif}}
+    {{if 'cudaLaunchAttributeCooperative' in found_values}}
 
-    #: 1 channel unsigned 8-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized8X1 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized8X2' in found_values}}
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeCooperative = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative{{endif}}
+    {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}}
 
-    #: 2 channel unsigned 8-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized8X2 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized8X4' in found_values}}
+    #: Valid for streams.
+    cudaLaunchAttributeSynchronizationPolicy = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy{{endif}}
+    {{if 'cudaLaunchAttributeClusterDimension' in found_values}}
 
-    #: 4 channel unsigned 8-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized8X4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized16X1' in found_values}}
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterDimension = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension{{endif}}
+    {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}}
 
-    #: 1 channel unsigned 16-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized16X1 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized16X2' in found_values}}
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterSchedulingPolicyPreference = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}}
 
-    #: 2 channel unsigned 16-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized16X2 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedNormalized16X4' in found_values}}
+    #: Valid for launches. Setting programmaticStreamSerializationAllowed
+    #: to non-0 signals that the kernel will use programmatic means to
+    #: resolve its stream dependency, so that the CUDA runtime should
+    #: opportunistically allow the grid's execution to overlap with the
+    #: previous kernel in the stream, if that kernel requests the overlap.
+    cudaLaunchAttributeProgrammaticStreamSerialization = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}}
 
-    #: 4 channel unsigned 16-bit normalized integer
-    cudaChannelFormatKindUnsignedNormalized16X4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized8X1' in found_values}}
+    #: Valid for launches. Event recorded through this launch attribute is
+    #: guaranteed to only trigger after all block in the associated kernel
+    #: trigger the event. A block can trigger the event through PTX
+    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
+    #: the beginning of each block's execution if triggerAtBlockStart is
+    #: set to non-0. Note that dependents (including the CPU thread calling
+    #: :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to observe
+    #: the release precisely when it is released. For example,
+    #: :py:obj:`~.cudaEventSynchronize()` may only observe the event
+    #: trigger long after the associated kernel has completed. This
+    #: recording type is primarily meant for establishing programmatic
+    #: dependency between device tasks. The event supplied must not be an
+    #: interprocess or interop event. The event must disable timing (i.e.
+    #: created with :py:obj:`~.cudaEventDisableTiming` flag set).
+    cudaLaunchAttributeProgrammaticEvent = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent{{endif}}
+    {{if 'cudaLaunchAttributePriority' in found_values}}
 
-    #: 1 channel signed 8-bit normalized integer
-    cudaChannelFormatKindSignedNormalized8X1 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized8X2' in found_values}}
+    #: Valid for graph nodes.
+    cudaLaunchAttributePriority = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority{{endif}}
+{{endif}}
+{{if 'cudaDataType_t' in found_types}}
 
-    #: 2 channel signed 8-bit normalized integer
-    cudaChannelFormatKindSignedNormalized8X2 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized8X4' in found_values}}
+class cudaDataType(IntEnum):
+    """"""
+    {{if 'CUDA_R_32F' in found_values}}
+    CUDA_R_32F = cyruntime.cudaDataType_t.CUDA_R_32F{{endif}}
+    {{if 'CUDA_R_64F' in found_values}}
+    CUDA_R_64F = cyruntime.cudaDataType_t.CUDA_R_64F{{endif}}
+    {{if 'CUDA_R_16F' in found_values}}
+    CUDA_R_16F = cyruntime.cudaDataType_t.CUDA_R_16F{{endif}}
+    {{if 'CUDA_R_8I' in found_values}}
+    CUDA_R_8I = cyruntime.cudaDataType_t.CUDA_R_8I{{endif}}
+    {{if 'CUDA_C_32F' in found_values}}
+    CUDA_C_32F = cyruntime.cudaDataType_t.CUDA_C_32F{{endif}}
+    {{if 'CUDA_C_64F' in found_values}}
+    CUDA_C_64F = cyruntime.cudaDataType_t.CUDA_C_64F{{endif}}
+    {{if 'CUDA_C_16F' in found_values}}
+    CUDA_C_16F = cyruntime.cudaDataType_t.CUDA_C_16F{{endif}}
+    {{if 'CUDA_C_8I' in found_values}}
+    CUDA_C_8I = cyruntime.cudaDataType_t.CUDA_C_8I{{endif}}
+    {{if 'CUDA_R_8U' in found_values}}
+    CUDA_R_8U = cyruntime.cudaDataType_t.CUDA_R_8U{{endif}}
+    {{if 'CUDA_C_8U' in found_values}}
+    CUDA_C_8U = cyruntime.cudaDataType_t.CUDA_C_8U{{endif}}
+    {{if 'CUDA_R_32I' in found_values}}
+    CUDA_R_32I = cyruntime.cudaDataType_t.CUDA_R_32I{{endif}}
+    {{if 'CUDA_C_32I' in found_values}}
+    CUDA_C_32I = cyruntime.cudaDataType_t.CUDA_C_32I{{endif}}
+    {{if 'CUDA_R_32U' in found_values}}
+    CUDA_R_32U = cyruntime.cudaDataType_t.CUDA_R_32U{{endif}}
+    {{if 'CUDA_C_32U' in found_values}}
+    CUDA_C_32U = cyruntime.cudaDataType_t.CUDA_C_32U{{endif}}
+    {{if 'CUDA_R_16BF' in found_values}}
+    CUDA_R_16BF = cyruntime.cudaDataType_t.CUDA_R_16BF{{endif}}
+    {{if 'CUDA_C_16BF' in found_values}}
+    CUDA_C_16BF = cyruntime.cudaDataType_t.CUDA_C_16BF{{endif}}
+    {{if 'CUDA_R_4I' in found_values}}
+    CUDA_R_4I = cyruntime.cudaDataType_t.CUDA_R_4I{{endif}}
+    {{if 'CUDA_C_4I' in found_values}}
+    CUDA_C_4I = cyruntime.cudaDataType_t.CUDA_C_4I{{endif}}
+    {{if 'CUDA_R_4U' in found_values}}
+    CUDA_R_4U = cyruntime.cudaDataType_t.CUDA_R_4U{{endif}}
+    {{if 'CUDA_C_4U' in found_values}}
+    CUDA_C_4U = cyruntime.cudaDataType_t.CUDA_C_4U{{endif}}
+    {{if 'CUDA_R_16I' in found_values}}
+    CUDA_R_16I = cyruntime.cudaDataType_t.CUDA_R_16I{{endif}}
+    {{if 'CUDA_C_16I' in found_values}}
+    CUDA_C_16I = cyruntime.cudaDataType_t.CUDA_C_16I{{endif}}
+    {{if 'CUDA_R_16U' in found_values}}
+    CUDA_R_16U = cyruntime.cudaDataType_t.CUDA_R_16U{{endif}}
+    {{if 'CUDA_C_16U' in found_values}}
+    CUDA_C_16U = cyruntime.cudaDataType_t.CUDA_C_16U{{endif}}
+    {{if 'CUDA_R_64I' in found_values}}
+    CUDA_R_64I = cyruntime.cudaDataType_t.CUDA_R_64I{{endif}}
+    {{if 'CUDA_C_64I' in found_values}}
+    CUDA_C_64I = cyruntime.cudaDataType_t.CUDA_C_64I{{endif}}
+    {{if 'CUDA_R_64U' in found_values}}
+    CUDA_R_64U = cyruntime.cudaDataType_t.CUDA_R_64U{{endif}}
+    {{if 'CUDA_C_64U' in found_values}}
+    CUDA_C_64U = cyruntime.cudaDataType_t.CUDA_C_64U{{endif}}
+    {{if 'CUDA_R_8F_E4M3' in found_values}}
+    CUDA_R_8F_E4M3 = cyruntime.cudaDataType_t.CUDA_R_8F_E4M3{{endif}}
+    {{if 'CUDA_R_8F_E5M2' in found_values}}
+    CUDA_R_8F_E5M2 = cyruntime.cudaDataType_t.CUDA_R_8F_E5M2{{endif}}
+{{endif}}
+{{if 'libraryPropertyType_t' in found_types}}
 
-    #: 4 channel signed 8-bit normalized integer
-    cudaChannelFormatKindSignedNormalized8X4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized16X1' in found_values}}
+class libraryPropertyType(IntEnum):
+    """"""
+    {{if 'MAJOR_VERSION' in found_values}}
+    MAJOR_VERSION = cyruntime.libraryPropertyType_t.MAJOR_VERSION{{endif}}
+    {{if 'MINOR_VERSION' in found_values}}
+    MINOR_VERSION = cyruntime.libraryPropertyType_t.MINOR_VERSION{{endif}}
+    {{if 'PATCH_LEVEL' in found_values}}
+    PATCH_LEVEL = cyruntime.libraryPropertyType_t.PATCH_LEVEL{{endif}}
+{{endif}}
+{{if True}}
 
-    #: 1 channel signed 16-bit normalized integer
-    cudaChannelFormatKindSignedNormalized16X1 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized16X2' in found_values}}
+class cudaEglFrameType(IntEnum):
+    """
+    CUDA EglFrame type - array or pointer
+    """
+    {{if True}}
 
-    #: 2 channel signed 16-bit normalized integer
-    cudaChannelFormatKindSignedNormalized16X2 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2{{endif}}
-    {{if 'cudaChannelFormatKindSignedNormalized16X4' in found_values}}
+    #: Frame type CUDA array
+    cudaEglFrameTypeArray = cyruntime.cudaEglFrameType_enum.cudaEglFrameTypeArray{{endif}}
+    {{if True}}
 
-    #: 4 channel signed 16-bit normalized integer
-    cudaChannelFormatKindSignedNormalized16X4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed1' in found_values}}
+    #: Frame type CUDA pointer
+    cudaEglFrameTypePitch = cyruntime.cudaEglFrameType_enum.cudaEglFrameTypePitch{{endif}}
+{{endif}}
+{{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC1 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed1 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed1SRGB' in found_values}}
+class cudaEglResourceLocationFlags(IntEnum):
+    """
+    Resource location flags- sysmem or vidmem  For CUDA context on
+    iGPU, since video and system memory are equivalent - these flags
+    will not have an effect on the execution.  For CUDA context on
+    dGPU, applications can use the flag
+    :py:obj:`~.cudaEglResourceLocationFlags` to give a hint about the
+    desired location.  :py:obj:`~.cudaEglResourceLocationSysmem` - the
+    frame data is made resident on the system memory to be accessed by
+    CUDA.  :py:obj:`~.cudaEglResourceLocationVidmem` - the frame data
+    is made resident on the dedicated video memory to be accessed by
+    CUDA.  There may be an additional latency due to new allocation and
+    data migration, if the frame is produced on a different memory.
+    """
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC1 compression)
-    #: format with sRGB encoding
-    cudaChannelFormatKindUnsignedBlockCompressed1SRGB = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed2' in found_values}}
+    #: Resource location sysmem
+    cudaEglResourceLocationSysmem = cyruntime.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationSysmem{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC2 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed2 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed2SRGB' in found_values}}
+    #: Resource location vidmem
+    cudaEglResourceLocationVidmem = cyruntime.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationVidmem{{endif}}
+{{endif}}
+{{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC2 compression)
-    #: format with sRGB encoding
-    cudaChannelFormatKindUnsignedBlockCompressed2SRGB = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed3' in found_values}}
+class cudaEglColorFormat(IntEnum):
+    """
+    CUDA EGL Color Format - The different planar and multiplanar
+    formats currently supported for CUDA_EGL interops.
+    """
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC3 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed3 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed3SRGB' in found_values}}
+    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC3 compression)
-    #: format with sRGB encoding
-    cudaChannelFormatKindUnsignedBlockCompressed3SRGB = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed4' in found_values}}
+    #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
+    #: width, height ratio same as YUV420Planar.
+    cudaEglColorFormatYUV420SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar{{endif}}
+    {{if True}}
 
-    #: 1 channel unsigned normalized block-compressed (BC4 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4{{endif}}
-    {{if 'cudaChannelFormatKindSignedBlockCompressed4' in found_values}}
+    #: Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V
+    #: height = Y height.
+    cudaEglColorFormatYUV422Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar{{endif}}
+    {{if True}}
 
-    #: 1 channel signed normalized block-compressed (BC4 compression)
-    #: format
-    cudaChannelFormatKindSignedBlockCompressed4 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed5' in found_values}}
+    #: Y, UV in two surfaces with VU byte ordering, width, height ratio
+    #: same as YUV422Planar.
+    cudaEglColorFormatYUV422SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar{{endif}}
+    {{if True}}
 
-    #: 2 channel unsigned normalized block-compressed (BC5 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed5 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5{{endif}}
-    {{if 'cudaChannelFormatKindSignedBlockCompressed5' in found_values}}
+    #: R/G/B/A four channels in one surface with BGRA byte ordering.
+    cudaEglColorFormatARGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatARGB{{endif}}
+    {{if True}}
 
-    #: 2 channel signed normalized block-compressed (BC5 compression)
-    #: format
-    cudaChannelFormatKindSignedBlockCompressed5 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed6H' in found_values}}
+    #: R/G/B/A four channels in one surface with ABGR byte ordering.
+    cudaEglColorFormatRGBA = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatRGBA{{endif}}
+    {{if True}}
 
-    #: 3 channel unsigned half-float block-compressed (BC6H compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed6H = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H{{endif}}
-    {{if 'cudaChannelFormatKindSignedBlockCompressed6H' in found_values}}
+    #: single luminance channel in one surface.
+    cudaEglColorFormatL = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatL{{endif}}
+    {{if True}}
 
-    #: 3 channel signed half-float block-compressed (BC6H compression)
-    #: format
-    cudaChannelFormatKindSignedBlockCompressed6H = ccudart.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed7' in found_values}}
+    #: single color channel in one surface.
+    cudaEglColorFormatR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatR{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC7 compression)
-    #: format
-    cudaChannelFormatKindUnsignedBlockCompressed7 = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7{{endif}}
-    {{if 'cudaChannelFormatKindUnsignedBlockCompressed7SRGB' in found_values}}
+    #: Y, U, V in three surfaces, each in a separate surface, U/V width = Y
+    #: width, U/V height = Y height.
+    cudaEglColorFormatYUV444Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned normalized block-compressed (BC7 compression)
-    #: format with sRGB encoding
-    cudaChannelFormatKindUnsignedBlockCompressed7SRGB = ccudart.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB{{endif}}
-{{endif}}
-{{if 'cudaMemoryType' in found_types}}
+    #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
+    #: width, height ratio same as YUV444Planar.
+    cudaEglColorFormatYUV444SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar{{endif}}
+    {{if True}}
 
-class cudaMemoryType(IntEnum):
-    """
-    CUDA memory types
-    """
-    {{if 'cudaMemoryTypeUnregistered' in found_values}}
+    #: Y, U, V in one surface, interleaved as UYVY in one channel.
+    cudaEglColorFormatYUYV422 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUYV422{{endif}}
+    {{if True}}
 
-    #: Unregistered memory
-    cudaMemoryTypeUnregistered = ccudart.cudaMemoryType.cudaMemoryTypeUnregistered{{endif}}
-    {{if 'cudaMemoryTypeHost' in found_values}}
+    #: Y, U, V in one surface, interleaved as YUYV in one channel.
+    cudaEglColorFormatUYVY422 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY422{{endif}}
+    {{if True}}
 
-    #: Host memory
-    cudaMemoryTypeHost = ccudart.cudaMemoryType.cudaMemoryTypeHost{{endif}}
-    {{if 'cudaMemoryTypeDevice' in found_values}}
+    #: R/G/B/A four channels in one surface with RGBA byte ordering.
+    cudaEglColorFormatABGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatABGR{{endif}}
+    {{if True}}
 
-    #: Device memory
-    cudaMemoryTypeDevice = ccudart.cudaMemoryType.cudaMemoryTypeDevice{{endif}}
-    {{if 'cudaMemoryTypeManaged' in found_values}}
+    #: R/G/B/A four channels in one surface with ARGB byte ordering.
+    cudaEglColorFormatBGRA = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBGRA{{endif}}
+    {{if True}}
 
-    #: Managed memory
-    cudaMemoryTypeManaged = ccudart.cudaMemoryType.cudaMemoryTypeManaged{{endif}}
-{{endif}}
-{{if 'cudaMemcpyKind' in found_types}}
+    #: Alpha color format - one channel in one surface.
+    cudaEglColorFormatA = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatA{{endif}}
+    {{if True}}
 
-class cudaMemcpyKind(IntEnum):
-    """
-    CUDA memory copy types
-    """
-    {{if 'cudaMemcpyHostToHost' in found_values}}
+    #: R/G color format - two channels in one surface with GR byte ordering
+    cudaEglColorFormatRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatRG{{endif}}
+    {{if True}}
 
-    #: Host -> Host
-    cudaMemcpyHostToHost = ccudart.cudaMemcpyKind.cudaMemcpyHostToHost{{endif}}
-    {{if 'cudaMemcpyHostToDevice' in found_values}}
+    #: Y, U, V, A four channels in one surface, interleaved as VUYA.
+    cudaEglColorFormatAYUV = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatAYUV{{endif}}
+    {{if True}}
 
-    #: Host -> Device
-    cudaMemcpyHostToDevice = ccudart.cudaMemcpyKind.cudaMemcpyHostToDevice{{endif}}
-    {{if 'cudaMemcpyDeviceToHost' in found_values}}
+    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
+    #: width = Y width, U/V height = Y height.
+    cudaEglColorFormatYVU444SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Device -> Host
-    cudaMemcpyDeviceToHost = ccudart.cudaMemcpyKind.cudaMemcpyDeviceToHost{{endif}}
-    {{if 'cudaMemcpyDeviceToDevice' in found_values}}
-
-    #: Device -> Device
-    cudaMemcpyDeviceToDevice = ccudart.cudaMemcpyKind.cudaMemcpyDeviceToDevice{{endif}}
-    {{if 'cudaMemcpyDefault' in found_values}}
+    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
+    #: width = 1/2 Y width, U/V height = Y height.
+    cudaEglColorFormatYVU422SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Direction of the transfer is inferred from the pointer values.
-    #: Requires unified virtual addressing
-    cudaMemcpyDefault = ccudart.cudaMemcpyKind.cudaMemcpyDefault{{endif}}
-{{endif}}
-{{if 'cudaAccessProperty' in found_types}}
+    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
+    #: width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar{{endif}}
+    {{if True}}
 
-class cudaAccessProperty(IntEnum):
-    """
-    Specifies performance hint with :py:obj:`~.cudaAccessPolicyWindow`
-    for hitProp and missProp members.
-    """
-    {{if 'cudaAccessPropertyNormal' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
+    #: ordering, U/V width = Y width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_444SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Normal cache persistence.
-    cudaAccessPropertyNormal = ccudart.cudaAccessProperty.cudaAccessPropertyNormal{{endif}}
-    {{if 'cudaAccessPropertyStreaming' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
+    #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY10V10U10_420SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Streaming access is less likely to persit from cache.
-    cudaAccessPropertyStreaming = ccudart.cudaAccessProperty.cudaAccessPropertyStreaming{{endif}}
-    {{if 'cudaAccessPropertyPersisting' in found_values}}
+    #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
+    #: ordering, U/V width = Y width, U/V height = Y height.
+    cudaEglColorFormatY12V12U12_444SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Persisting access is more likely to persist in cache.
-    cudaAccessPropertyPersisting = ccudart.cudaAccessProperty.cudaAccessPropertyPersisting{{endif}}
-{{endif}}
-{{if 'cudaStreamCaptureStatus' in found_types}}
+    #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
+    #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY12V12U12_420SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar{{endif}}
+    {{if True}}
 
-class cudaStreamCaptureStatus(IntEnum):
-    """
-    Possible stream capture statuses returned by
-    :py:obj:`~.cudaStreamIsCapturing`
-    """
-    {{if 'cudaStreamCaptureStatusNone' in found_values}}
+    #: Extended Range Y, U, V in one surface, interleaved as YVYU in one
+    #: channel.
+    cudaEglColorFormatVYUY_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatVYUY_ER{{endif}}
+    {{if True}}
 
-    #: Stream is not capturing
-    cudaStreamCaptureStatusNone = ccudart.cudaStreamCaptureStatus.cudaStreamCaptureStatusNone{{endif}}
-    {{if 'cudaStreamCaptureStatusActive' in found_values}}
+    #: Extended Range Y, U, V in one surface, interleaved as YUYV in one
+    #: channel.
+    cudaEglColorFormatUYVY_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatUYVY_ER{{endif}}
+    {{if True}}
 
-    #: Stream is actively capturing
-    cudaStreamCaptureStatusActive = ccudart.cudaStreamCaptureStatus.cudaStreamCaptureStatusActive{{endif}}
-    {{if 'cudaStreamCaptureStatusInvalidated' in found_values}}
+    #: Extended Range Y, U, V in one surface, interleaved as UYVY in one
+    #: channel.
+    cudaEglColorFormatYUYV_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUYV_ER{{endif}}
+    {{if True}}
 
-    #: Stream is part of a capture sequence that has been invalidated, but
-    #: not terminated
-    cudaStreamCaptureStatusInvalidated = ccudart.cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated{{endif}}
-{{endif}}
-{{if 'cudaStreamCaptureMode' in found_types}}
+    #: Extended Range Y, U, V in one surface, interleaved as VYUY in one
+    #: channel.
+    cudaEglColorFormatYVYU_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVYU_ER{{endif}}
+    {{if True}}
 
-class cudaStreamCaptureMode(IntEnum):
-    """
-    Possible modes for stream capture thread interactions. For more
-    details see :py:obj:`~.cudaStreamBeginCapture` and
-    :py:obj:`~.cudaThreadExchangeStreamCaptureMode`
-    """
-    {{if 'cudaStreamCaptureModeGlobal' in found_values}}
-    cudaStreamCaptureModeGlobal = ccudart.cudaStreamCaptureMode.cudaStreamCaptureModeGlobal{{endif}}
-    {{if 'cudaStreamCaptureModeThreadLocal' in found_values}}
-    cudaStreamCaptureModeThreadLocal = ccudart.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal{{endif}}
-    {{if 'cudaStreamCaptureModeRelaxed' in found_values}}
-    cudaStreamCaptureModeRelaxed = ccudart.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed{{endif}}
-{{endif}}
-{{if 'cudaSynchronizationPolicy' in found_types}}
+    #: Extended Range Y, U, V, A four channels in one surface, interleaved
+    #: as AVUY.
+    cudaEglColorFormatYUVA_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUVA_ER{{endif}}
+    {{if True}}
 
-class cudaSynchronizationPolicy(IntEnum):
-    """
+    #: Extended Range Y, U, V, A four channels in one surface, interleaved
+    #: as VUYA.
+    cudaEglColorFormatAYUV_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatAYUV_ER{{endif}}
+    {{if True}}
 
-    """
-    {{if 'cudaSyncPolicyAuto' in found_values}}
-    cudaSyncPolicyAuto = ccudart.cudaSynchronizationPolicy.cudaSyncPolicyAuto{{endif}}
-    {{if 'cudaSyncPolicySpin' in found_values}}
-    cudaSyncPolicySpin = ccudart.cudaSynchronizationPolicy.cudaSyncPolicySpin{{endif}}
-    {{if 'cudaSyncPolicyYield' in found_values}}
-    cudaSyncPolicyYield = ccudart.cudaSynchronizationPolicy.cudaSyncPolicyYield{{endif}}
-    {{if 'cudaSyncPolicyBlockingSync' in found_values}}
-    cudaSyncPolicyBlockingSync = ccudart.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync{{endif}}
-{{endif}}
-{{if 'cudaClusterSchedulingPolicy' in found_types}}
+    #: Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V
+    #: height = Y height.
+    cudaEglColorFormatYUV444Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar_ER{{endif}}
+    {{if True}}
 
-class cudaClusterSchedulingPolicy(IntEnum):
-    """
-    Cluster scheduling policies. These may be passed to
-    :py:obj:`~.cudaFuncSetAttribute`
-    """
-    {{if 'cudaClusterSchedulingPolicyDefault' in found_values}}
+    #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
+    #: U/V height = Y height.
+    cudaEglColorFormatYUV422Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar_ER{{endif}}
+    {{if True}}
 
-    #: the default policy
-    cudaClusterSchedulingPolicyDefault = ccudart.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyDefault{{endif}}
-    {{if 'cudaClusterSchedulingPolicySpread' in found_values}}
+    #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_ER{{endif}}
+    {{if True}}
 
-    #: spread the blocks within a cluster to the SMs
-    cudaClusterSchedulingPolicySpread = ccudart.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicySpread{{endif}}
-    {{if 'cudaClusterSchedulingPolicyLoadBalancing' in found_values}}
+    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
+    #: byte ordering, U/V width = Y width, U/V height = Y height.
+    cudaEglColorFormatYUV444SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: allow the hardware to load-balance the blocks in a cluster to the
-    #: SMs
-    cudaClusterSchedulingPolicyLoadBalancing = ccudart.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyLoadBalancing{{endif}}
-{{endif}}
-{{if 'cudaStreamUpdateCaptureDependenciesFlags' in found_types}}
+    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
+    #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+    cudaEglColorFormatYUV422SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar_ER{{endif}}
+    {{if True}}
 
-class cudaStreamUpdateCaptureDependenciesFlags(IntEnum):
-    """
-    Flags for :py:obj:`~.cudaStreamUpdateCaptureDependencies`
-    """
-    {{if 'cudaStreamAddCaptureDependencies' in found_values}}
+    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
+    #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: Add new nodes to the dependency set
-    cudaStreamAddCaptureDependencies = ccudart.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamAddCaptureDependencies{{endif}}
-    {{if 'cudaStreamSetCaptureDependencies' in found_values}}
+    #: Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V
+    #: height = Y height.
+    cudaEglColorFormatYVU444Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar_ER{{endif}}
+    {{if True}}
 
-    #: Replace the dependency set with the new nodes
-    cudaStreamSetCaptureDependencies = ccudart.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamSetCaptureDependencies{{endif}}
-{{endif}}
-{{if 'cudaUserObjectFlags' in found_types}}
+    #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
+    #: U/V height = Y height.
+    cudaEglColorFormatYVU422Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar_ER{{endif}}
+    {{if True}}
 
-class cudaUserObjectFlags(IntEnum):
-    """
-    Flags for user objects for graphs
-    """
-    {{if 'cudaUserObjectNoDestructorSync' in found_values}}
+    #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420Planar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_ER{{endif}}
+    {{if True}}
 
-    #: Indicates the destructor execution is not synchronized by any CUDA
-    #: handle.
-    cudaUserObjectNoDestructorSync = ccudart.cudaUserObjectFlags.cudaUserObjectNoDestructorSync{{endif}}
-{{endif}}
-{{if 'cudaUserObjectRetainFlags' in found_types}}
+    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
+    #: byte ordering, U/V width = Y width, U/V height = Y height.
+    cudaEglColorFormatYVU444SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar_ER{{endif}}
+    {{if True}}
 
-class cudaUserObjectRetainFlags(IntEnum):
-    """
-    Flags for retaining user object references for graphs
-    """
-    {{if 'cudaGraphUserObjectMove' in found_values}}
+    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
+    #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+    cudaEglColorFormatYVU422SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: Transfer references from the caller rather than creating new
-    #: references.
-    cudaGraphUserObjectMove = ccudart.cudaUserObjectRetainFlags.cudaGraphUserObjectMove{{endif}}
-{{endif}}
-{{if 'cudaGraphicsRegisterFlags' in found_types}}
+    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
+    #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_ER{{endif}}
+    {{if True}}
 
-class cudaGraphicsRegisterFlags(IntEnum):
-    """
-    CUDA graphics interop register flags
-    """
-    {{if 'cudaGraphicsRegisterFlagsNone' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved RGGB
+    #: ordering.
+    cudaEglColorFormatBayerRGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerRGGB{{endif}}
+    {{if True}}
 
-    #: Default
-    cudaGraphicsRegisterFlagsNone = ccudart.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsNone{{endif}}
-    {{if 'cudaGraphicsRegisterFlagsReadOnly' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved BGGR
+    #: ordering.
+    cudaEglColorFormatBayerBGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerBGGR{{endif}}
+    {{if True}}
 
-    #: CUDA will not write to this resource
-    cudaGraphicsRegisterFlagsReadOnly = ccudart.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsReadOnly{{endif}}
-    {{if 'cudaGraphicsRegisterFlagsWriteDiscard' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved GRBG
+    #: ordering.
+    cudaEglColorFormatBayerGRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerGRBG{{endif}}
+    {{if True}}
 
-    #: CUDA will only write to and will not read from this resource
-    cudaGraphicsRegisterFlagsWriteDiscard = ccudart.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsWriteDiscard{{endif}}
-    {{if 'cudaGraphicsRegisterFlagsSurfaceLoadStore' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved GBRG
+    #: ordering.
+    cudaEglColorFormatBayerGBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerGBRG{{endif}}
+    {{if True}}
 
-    #: CUDA will bind this resource to a surface reference
-    cudaGraphicsRegisterFlagsSurfaceLoadStore = ccudart.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsSurfaceLoadStore{{endif}}
-    {{if 'cudaGraphicsRegisterFlagsTextureGather' in found_values}}
+    #: Bayer10 format - one channel in one surface with interleaved RGGB
+    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+    cudaEglColorFormatBayer10RGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10RGGB{{endif}}
+    {{if True}}
 
-    #: CUDA will perform texture gather operations on this resource
-    cudaGraphicsRegisterFlagsTextureGather = ccudart.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsTextureGather{{endif}}
-{{endif}}
-{{if 'cudaGraphicsMapFlags' in found_types}}
+    #: Bayer10 format - one channel in one surface with interleaved BGGR
+    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+    cudaEglColorFormatBayer10BGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10BGGR{{endif}}
+    {{if True}}
 
-class cudaGraphicsMapFlags(IntEnum):
-    """
-    CUDA graphics interop map flags
-    """
-    {{if 'cudaGraphicsMapFlagsNone' in found_values}}
+    #: Bayer10 format - one channel in one surface with interleaved GRBG
+    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+    cudaEglColorFormatBayer10GRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GRBG{{endif}}
+    {{if True}}
 
-    #: Default; Assume resource can be read/written
-    cudaGraphicsMapFlagsNone = ccudart.cudaGraphicsMapFlags.cudaGraphicsMapFlagsNone{{endif}}
-    {{if 'cudaGraphicsMapFlagsReadOnly' in found_values}}
+    #: Bayer10 format - one channel in one surface with interleaved GBRG
+    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+    cudaEglColorFormatBayer10GBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GBRG{{endif}}
+    {{if True}}
 
-    #: CUDA will not write to this resource
-    cudaGraphicsMapFlagsReadOnly = ccudart.cudaGraphicsMapFlags.cudaGraphicsMapFlagsReadOnly{{endif}}
-    {{if 'cudaGraphicsMapFlagsWriteDiscard' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved RGGB
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12RGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RGGB{{endif}}
+    {{if True}}
 
-    #: CUDA will only write to and will not read from this resource
-    cudaGraphicsMapFlagsWriteDiscard = ccudart.cudaGraphicsMapFlags.cudaGraphicsMapFlagsWriteDiscard{{endif}}
-{{endif}}
-{{if 'cudaGraphicsCubeFace' in found_types}}
+    #: Bayer12 format - one channel in one surface with interleaved BGGR
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12BGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BGGR{{endif}}
+    {{if True}}
 
-class cudaGraphicsCubeFace(IntEnum):
-    """
-    CUDA graphics interop array indices for cube maps
-    """
-    {{if 'cudaGraphicsCubeFacePositiveX' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved GRBG
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12GRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GRBG{{endif}}
+    {{if True}}
 
-    #: Positive X face of cubemap
-    cudaGraphicsCubeFacePositiveX = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveX{{endif}}
-    {{if 'cudaGraphicsCubeFaceNegativeX' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved GBRG
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12GBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GBRG{{endif}}
+    {{if True}}
 
-    #: Negative X face of cubemap
-    cudaGraphicsCubeFaceNegativeX = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeX{{endif}}
-    {{if 'cudaGraphicsCubeFacePositiveY' in found_values}}
+    #: Bayer14 format - one channel in one surface with interleaved RGGB
+    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+    cudaEglColorFormatBayer14RGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14RGGB{{endif}}
+    {{if True}}
 
-    #: Positive Y face of cubemap
-    cudaGraphicsCubeFacePositiveY = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveY{{endif}}
-    {{if 'cudaGraphicsCubeFaceNegativeY' in found_values}}
+    #: Bayer14 format - one channel in one surface with interleaved BGGR
+    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+    cudaEglColorFormatBayer14BGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14BGGR{{endif}}
+    {{if True}}
 
-    #: Negative Y face of cubemap
-    cudaGraphicsCubeFaceNegativeY = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeY{{endif}}
-    {{if 'cudaGraphicsCubeFacePositiveZ' in found_values}}
+    #: Bayer14 format - one channel in one surface with interleaved GRBG
+    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+    cudaEglColorFormatBayer14GRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GRBG{{endif}}
+    {{if True}}
 
-    #: Positive Z face of cubemap
-    cudaGraphicsCubeFacePositiveZ = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveZ{{endif}}
-    {{if 'cudaGraphicsCubeFaceNegativeZ' in found_values}}
+    #: Bayer14 format - one channel in one surface with interleaved GBRG
+    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+    cudaEglColorFormatBayer14GBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GBRG{{endif}}
+    {{if True}}
 
-    #: Negative Z face of cubemap
-    cudaGraphicsCubeFaceNegativeZ = ccudart.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeZ{{endif}}
-{{endif}}
-{{if 'cudaResourceType' in found_types}}
+    #: Bayer20 format - one channel in one surface with interleaved RGGB
+    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+    cudaEglColorFormatBayer20RGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20RGGB{{endif}}
+    {{if True}}
 
-class cudaResourceType(IntEnum):
-    """
-    CUDA resource types
-    """
-    {{if 'cudaResourceTypeArray' in found_values}}
+    #: Bayer20 format - one channel in one surface with interleaved BGGR
+    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+    cudaEglColorFormatBayer20BGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20BGGR{{endif}}
+    {{if True}}
 
-    #: Array resource
-    cudaResourceTypeArray = ccudart.cudaResourceType.cudaResourceTypeArray{{endif}}
-    {{if 'cudaResourceTypeMipmappedArray' in found_values}}
+    #: Bayer20 format - one channel in one surface with interleaved GRBG
+    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+    cudaEglColorFormatBayer20GRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GRBG{{endif}}
+    {{if True}}
 
-    #: Mipmapped array resource
-    cudaResourceTypeMipmappedArray = ccudart.cudaResourceType.cudaResourceTypeMipmappedArray{{endif}}
-    {{if 'cudaResourceTypeLinear' in found_values}}
+    #: Bayer20 format - one channel in one surface with interleaved GBRG
+    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+    cudaEglColorFormatBayer20GBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GBRG{{endif}}
+    {{if True}}
 
-    #: Linear resource
-    cudaResourceTypeLinear = ccudart.cudaResourceType.cudaResourceTypeLinear{{endif}}
-    {{if 'cudaResourceTypePitch2D' in found_values}}
+    #: Y, V, U in three surfaces, each in a separate surface, U/V width = Y
+    #: width, U/V height = Y height.
+    cudaEglColorFormatYVU444Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar{{endif}}
+    {{if True}}
 
-    #: Pitch 2D resource
-    cudaResourceTypePitch2D = ccudart.cudaResourceType.cudaResourceTypePitch2D{{endif}}
-{{endif}}
-{{if 'cudaResourceViewFormat' in found_types}}
+    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = Y height.
+    cudaEglColorFormatYVU422Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar{{endif}}
+    {{if True}}
 
-class cudaResourceViewFormat(IntEnum):
-    """
-    CUDA texture resource view formats
-    """
-    {{if 'cudaResViewFormatNone' in found_values}}
+    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420Planar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar{{endif}}
+    {{if True}}
 
-    #: No resource view format (use underlying resource format)
-    cudaResViewFormatNone = ccudart.cudaResourceViewFormat.cudaResViewFormatNone{{endif}}
-    {{if 'cudaResViewFormatUnsignedChar1' in found_values}}
+    #: Nvidia proprietary Bayer ISP format - one channel in one surface
+    #: with interleaved RGGB ordering and mapped to opaque integer
+    #: datatype.
+    cudaEglColorFormatBayerIspRGGB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspRGGB{{endif}}
+    {{if True}}
 
-    #: 1 channel unsigned 8-bit integers
-    cudaResViewFormatUnsignedChar1 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedChar1{{endif}}
-    {{if 'cudaResViewFormatUnsignedChar2' in found_values}}
+    #: Nvidia proprietary Bayer ISP format - one channel in one surface
+    #: with interleaved BGGR ordering and mapped to opaque integer
+    #: datatype.
+    cudaEglColorFormatBayerIspBGGR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspBGGR{{endif}}
+    {{if True}}
 
-    #: 2 channel unsigned 8-bit integers
-    cudaResViewFormatUnsignedChar2 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedChar2{{endif}}
-    {{if 'cudaResViewFormatUnsignedChar4' in found_values}}
+    #: Nvidia proprietary Bayer ISP format - one channel in one surface
+    #: with interleaved GRBG ordering and mapped to opaque integer
+    #: datatype.
+    cudaEglColorFormatBayerIspGRBG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGRBG{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned 8-bit integers
-    cudaResViewFormatUnsignedChar4 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedChar4{{endif}}
-    {{if 'cudaResViewFormatSignedChar1' in found_values}}
+    #: Nvidia proprietary Bayer ISP format - one channel in one surface
+    #: with interleaved GBRG ordering and mapped to opaque integer
+    #: datatype.
+    cudaEglColorFormatBayerIspGBRG = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGBRG{{endif}}
+    {{if True}}
 
-    #: 1 channel signed 8-bit integers
-    cudaResViewFormatSignedChar1 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedChar1{{endif}}
-    {{if 'cudaResViewFormatSignedChar2' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved BCCR
+    #: ordering.
+    cudaEglColorFormatBayerBCCR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerBCCR{{endif}}
+    {{if True}}
 
-    #: 2 channel signed 8-bit integers
-    cudaResViewFormatSignedChar2 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedChar2{{endif}}
-    {{if 'cudaResViewFormatSignedChar4' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved RCCB
+    #: ordering.
+    cudaEglColorFormatBayerRCCB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerRCCB{{endif}}
+    {{if True}}
 
-    #: 4 channel signed 8-bit integers
-    cudaResViewFormatSignedChar4 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedChar4{{endif}}
-    {{if 'cudaResViewFormatUnsignedShort1' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved CRBC
+    #: ordering.
+    cudaEglColorFormatBayerCRBC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerCRBC{{endif}}
+    {{if True}}
 
-    #: 1 channel unsigned 16-bit integers
-    cudaResViewFormatUnsignedShort1 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedShort1{{endif}}
-    {{if 'cudaResViewFormatUnsignedShort2' in found_values}}
+    #: Bayer format - one channel in one surface with interleaved CBRC
+    #: ordering.
+    cudaEglColorFormatBayerCBRC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayerCBRC{{endif}}
+    {{if True}}
 
-    #: 2 channel unsigned 16-bit integers
-    cudaResViewFormatUnsignedShort2 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedShort2{{endif}}
-    {{if 'cudaResViewFormatUnsignedShort4' in found_values}}
+    #: Bayer10 format - one channel in one surface with interleaved CCCC
+    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+    cudaEglColorFormatBayer10CCCC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer10CCCC{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned 16-bit integers
-    cudaResViewFormatUnsignedShort4 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedShort4{{endif}}
-    {{if 'cudaResViewFormatSignedShort1' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved BCCR
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12BCCR = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BCCR{{endif}}
+    {{if True}}
 
-    #: 1 channel signed 16-bit integers
-    cudaResViewFormatSignedShort1 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedShort1{{endif}}
-    {{if 'cudaResViewFormatSignedShort2' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved RCCB
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12RCCB = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RCCB{{endif}}
+    {{if True}}
 
-    #: 2 channel signed 16-bit integers
-    cudaResViewFormatSignedShort2 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedShort2{{endif}}
-    {{if 'cudaResViewFormatSignedShort4' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved CRBC
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12CRBC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CRBC{{endif}}
+    {{if True}}
 
-    #: 4 channel signed 16-bit integers
-    cudaResViewFormatSignedShort4 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedShort4{{endif}}
-    {{if 'cudaResViewFormatUnsignedInt1' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved CBRC
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12CBRC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CBRC{{endif}}
+    {{if True}}
 
-    #: 1 channel unsigned 32-bit integers
-    cudaResViewFormatUnsignedInt1 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedInt1{{endif}}
-    {{if 'cudaResViewFormatUnsignedInt2' in found_values}}
+    #: Bayer12 format - one channel in one surface with interleaved CCCC
+    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+    cudaEglColorFormatBayer12CCCC = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CCCC{{endif}}
+    {{if True}}
 
-    #: 2 channel unsigned 32-bit integers
-    cudaResViewFormatUnsignedInt2 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedInt2{{endif}}
-    {{if 'cudaResViewFormatUnsignedInt4' in found_values}}
+    #: Color format for single Y plane.
+    cudaEglColorFormatY = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY{{endif}}
+    {{if True}}
 
-    #: 4 channel unsigned 32-bit integers
-    cudaResViewFormatUnsignedInt4 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedInt4{{endif}}
-    {{if 'cudaResViewFormatSignedInt1' in found_values}}
+    #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420SemiPlanar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_2020{{endif}}
+    {{if True}}
 
-    #: 1 channel signed 32-bit integers
-    cudaResViewFormatSignedInt1 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedInt1{{endif}}
-    {{if 'cudaResViewFormatSignedInt2' in found_values}}
+    #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420SemiPlanar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_2020{{endif}}
+    {{if True}}
 
-    #: 2 channel signed 32-bit integers
-    cudaResViewFormatSignedInt2 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedInt2{{endif}}
-    {{if 'cudaResViewFormatSignedInt4' in found_values}}
+    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420Planar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_2020{{endif}}
+    {{if True}}
 
-    #: 4 channel signed 32-bit integers
-    cudaResViewFormatSignedInt4 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedInt4{{endif}}
-    {{if 'cudaResViewFormatHalf1' in found_values}}
+    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420Planar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_2020{{endif}}
+    {{if True}}
 
-    #: 1 channel 16-bit floating point
-    cudaResViewFormatHalf1 = ccudart.cudaResourceViewFormat.cudaResViewFormatHalf1{{endif}}
-    {{if 'cudaResViewFormatHalf2' in found_values}}
+    #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420SemiPlanar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_709{{endif}}
+    {{if True}}
 
-    #: 2 channel 16-bit floating point
-    cudaResViewFormatHalf2 = ccudart.cudaResourceViewFormat.cudaResViewFormatHalf2{{endif}}
-    {{if 'cudaResViewFormatHalf4' in found_values}}
+    #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
+    #: U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420SemiPlanar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_709{{endif}}
+    {{if True}}
 
-    #: 4 channel 16-bit floating point
-    cudaResViewFormatHalf4 = ccudart.cudaResourceViewFormat.cudaResViewFormatHalf4{{endif}}
-    {{if 'cudaResViewFormatFloat1' in found_values}}
+    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYUV420Planar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_709{{endif}}
+    {{if True}}
 
-    #: 1 channel 32-bit floating point
-    cudaResViewFormatFloat1 = ccudart.cudaResourceViewFormat.cudaResViewFormatFloat1{{endif}}
-    {{if 'cudaResViewFormatFloat2' in found_values}}
+    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
+    #: 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatYVU420Planar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_709{{endif}}
+    {{if True}}
 
-    #: 2 channel 32-bit floating point
-    cudaResViewFormatFloat2 = ccudart.cudaResourceViewFormat.cudaResViewFormatFloat2{{endif}}
-    {{if 'cudaResViewFormatFloat4' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
+    #: width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709{{endif}}
+    {{if True}}
 
-    #: 4 channel 32-bit floating point
-    cudaResViewFormatFloat4 = ccudart.cudaResourceViewFormat.cudaResViewFormatFloat4{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed1' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
+    #: width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_2020{{endif}}
+    {{if True}}
 
-    #: Block compressed 1
-    cudaResViewFormatUnsignedBlockCompressed1 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed1{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed2' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
+    #: width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_2020{{endif}}
+    {{if True}}
 
-    #: Block compressed 2
-    cudaResViewFormatUnsignedBlockCompressed2 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed2{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed3' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
+    #: width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_422SemiPlanar = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar{{endif}}
+    {{if True}}
 
-    #: Block compressed 3
-    cudaResViewFormatUnsignedBlockCompressed3 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed3{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed4' in found_values}}
+    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
+    #: width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_422SemiPlanar_709 = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_709{{endif}}
+    {{if True}}
 
-    #: Block compressed 4 unsigned
-    cudaResViewFormatUnsignedBlockCompressed4 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed4{{endif}}
-    {{if 'cudaResViewFormatSignedBlockCompressed4' in found_values}}
+    #: Extended Range Color format for single Y plane.
+    cudaEglColorFormatY_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 4 signed
-    cudaResViewFormatSignedBlockCompressed4 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed4{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed5' in found_values}}
+    #: Extended Range Color format for single Y plane.
+    cudaEglColorFormatY_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY_709_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 5 unsigned
-    cudaResViewFormatUnsignedBlockCompressed5 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed5{{endif}}
-    {{if 'cudaResViewFormatSignedBlockCompressed5' in found_values}}
+    #: Extended Range Color format for single Y10 plane.
+    cudaEglColorFormatY10_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 5 signed
-    cudaResViewFormatSignedBlockCompressed5 = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed5{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed6H' in found_values}}
+    #: Extended Range Color format for single Y10 plane.
+    cudaEglColorFormatY10_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10_709_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 6 unsigned half-float
-    cudaResViewFormatUnsignedBlockCompressed6H = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed6H{{endif}}
-    {{if 'cudaResViewFormatSignedBlockCompressed6H' in found_values}}
+    #: Extended Range Color format for single Y12 plane.
+    cudaEglColorFormatY12_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 6 signed half-float
-    cudaResViewFormatSignedBlockCompressed6H = ccudart.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed6H{{endif}}
-    {{if 'cudaResViewFormatUnsignedBlockCompressed7' in found_values}}
+    #: Extended Range Color format for single Y12 plane.
+    cudaEglColorFormatY12_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12_709_ER{{endif}}
+    {{if True}}
 
-    #: Block compressed 7
-    cudaResViewFormatUnsignedBlockCompressed7 = ccudart.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed7{{endif}}
-{{endif}}
-{{if 'cudaFuncAttribute' in found_types}}
+    #: Y, U, V, A four channels in one surface, interleaved as AVUY.
+    cudaEglColorFormatYUVA = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYUVA{{endif}}
+    {{if True}}
 
-class cudaFuncAttribute(IntEnum):
-    """
-    CUDA function attributes that can be set using
-    :py:obj:`~.cudaFuncSetAttribute`
-    """
-    {{if 'cudaFuncAttributeMaxDynamicSharedMemorySize' in found_values}}
+    #: Y, U, V in one surface, interleaved as YVYU in one channel.
+    cudaEglColorFormatYVYU = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatYVYU{{endif}}
+    {{if True}}
 
-    #: Maximum dynamic shared memory size
-    cudaFuncAttributeMaxDynamicSharedMemorySize = ccudart.cudaFuncAttribute.cudaFuncAttributeMaxDynamicSharedMemorySize{{endif}}
-    {{if 'cudaFuncAttributePreferredSharedMemoryCarveout' in found_values}}
+    #: Y, U, V in one surface, interleaved as VYUY in one channel.
+    cudaEglColorFormatVYUY = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatVYUY{{endif}}
+    {{if True}}
 
-    #: Preferred shared memory-L1 cache split
-    cudaFuncAttributePreferredSharedMemoryCarveout = ccudart.cudaFuncAttribute.cudaFuncAttributePreferredSharedMemoryCarveout{{endif}}
-    {{if 'cudaFuncAttributeClusterDimMustBeSet' in found_values}}
+    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
+    #: width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY10V10U10_420SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: Indicator to enforce valid cluster dimension specification on kernel
-    #: launch
-    cudaFuncAttributeClusterDimMustBeSet = ccudart.cudaFuncAttribute.cudaFuncAttributeClusterDimMustBeSet{{endif}}
-    {{if 'cudaFuncAttributeRequiredClusterWidth' in found_values}}
+    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
+    #: width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER{{endif}}
+    {{if True}}
 
-    #: Required cluster width
-    cudaFuncAttributeRequiredClusterWidth = ccudart.cudaFuncAttribute.cudaFuncAttributeRequiredClusterWidth{{endif}}
-    {{if 'cudaFuncAttributeRequiredClusterHeight' in found_values}}
+    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
+    #: width = Y width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_444SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: Required cluster height
-    cudaFuncAttributeRequiredClusterHeight = ccudart.cudaFuncAttribute.cudaFuncAttributeRequiredClusterHeight{{endif}}
-    {{if 'cudaFuncAttributeRequiredClusterDepth' in found_values}}
+    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
+    #: width = Y width, U/V height = Y height.
+    cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER{{endif}}
+    {{if True}}
 
-    #: Required cluster depth
-    cudaFuncAttributeRequiredClusterDepth = ccudart.cudaFuncAttribute.cudaFuncAttributeRequiredClusterDepth{{endif}}
-    {{if 'cudaFuncAttributeNonPortableClusterSizeAllowed' in found_values}}
+    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
+    #: width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY12V12U12_420SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_ER{{endif}}
+    {{if True}}
 
-    #: Whether non-portable cluster scheduling policy is supported
-    cudaFuncAttributeNonPortableClusterSizeAllowed = ccudart.cudaFuncAttribute.cudaFuncAttributeNonPortableClusterSizeAllowed{{endif}}
-    {{if 'cudaFuncAttributeClusterSchedulingPolicyPreference' in found_values}}
+    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
+    #: width = 1/2 Y width, U/V height = 1/2 Y height.
+    cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER{{endif}}
+    {{if True}}
 
-    #: Required cluster scheduling policy preference
-    cudaFuncAttributeClusterSchedulingPolicyPreference = ccudart.cudaFuncAttribute.cudaFuncAttributeClusterSchedulingPolicyPreference{{endif}}
-    {{if 'cudaFuncAttributeMax' in found_values}}
-    cudaFuncAttributeMax = ccudart.cudaFuncAttribute.cudaFuncAttributeMax{{endif}}
+    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
+    #: width = Y width, U/V height = Y height.
+    cudaEglColorFormatY12V12U12_444SemiPlanar_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_ER{{endif}}
+    {{if True}}
+
+    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
+    #: width = Y width, U/V height = Y height.
+    cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = cyruntime.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER{{endif}}
 {{endif}}
-{{if 'cudaFuncCache' in found_types}}
+{{if 'cudaChannelFormatKind' in found_types}}
 
-class cudaFuncCache(IntEnum):
+class cudaChannelFormatKind(IntEnum):
     """
-    CUDA function cache configurations
+    Channel format kind
     """
-    {{if 'cudaFuncCachePreferNone' in found_values}}
-
-    #: Default function cache configuration, no preference
-    cudaFuncCachePreferNone = ccudart.cudaFuncCache.cudaFuncCachePreferNone{{endif}}
-    {{if 'cudaFuncCachePreferShared' in found_values}}
+    {{if 'cudaChannelFormatKindSigned' in found_values}}
 
-    #: Prefer larger shared memory and smaller L1 cache
-    cudaFuncCachePreferShared = ccudart.cudaFuncCache.cudaFuncCachePreferShared{{endif}}
-    {{if 'cudaFuncCachePreferL1' in found_values}}
+    #: Signed channel format
+    cudaChannelFormatKindSigned = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSigned{{endif}}
+    {{if 'cudaChannelFormatKindUnsigned' in found_values}}
 
-    #: Prefer larger L1 cache and smaller shared memory
-    cudaFuncCachePreferL1 = ccudart.cudaFuncCache.cudaFuncCachePreferL1{{endif}}
-    {{if 'cudaFuncCachePreferEqual' in found_values}}
+    #: Unsigned channel format
+    cudaChannelFormatKindUnsigned = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned{{endif}}
+    {{if 'cudaChannelFormatKindFloat' in found_values}}
 
-    #: Prefer equal size L1 cache and shared memory
-    cudaFuncCachePreferEqual = ccudart.cudaFuncCache.cudaFuncCachePreferEqual{{endif}}
-{{endif}}
-{{if 'cudaSharedMemConfig' in found_types}}
+    #: Float channel format
+    cudaChannelFormatKindFloat = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindFloat{{endif}}
+    {{if 'cudaChannelFormatKindNone' in found_values}}
 
-class cudaSharedMemConfig(IntEnum):
-    """
-    CUDA shared memory configuration
-    """
-    {{if 'cudaSharedMemBankSizeDefault' in found_values}}
-    cudaSharedMemBankSizeDefault = ccudart.cudaSharedMemConfig.cudaSharedMemBankSizeDefault{{endif}}
-    {{if 'cudaSharedMemBankSizeFourByte' in found_values}}
-    cudaSharedMemBankSizeFourByte = ccudart.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte{{endif}}
-    {{if 'cudaSharedMemBankSizeEightByte' in found_values}}
-    cudaSharedMemBankSizeEightByte = ccudart.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte{{endif}}
-{{endif}}
-{{if 'cudaSharedCarveout' in found_types}}
+    #: No channel format
+    cudaChannelFormatKindNone = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindNone{{endif}}
+    {{if 'cudaChannelFormatKindNV12' in found_values}}
 
-class cudaSharedCarveout(IntEnum):
-    """
-    Shared memory carveout configurations. These may be passed to
-    cudaFuncSetAttribute
-    """
-    {{if 'cudaSharedmemCarveoutDefault' in found_values}}
+    #: Unsigned 8-bit integers, planar 4:2:0 YUV format
+    cudaChannelFormatKindNV12 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindNV12{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized8X1' in found_values}}
 
-    #: No preference for shared memory or L1 (default)
-    cudaSharedmemCarveoutDefault = ccudart.cudaSharedCarveout.cudaSharedmemCarveoutDefault{{endif}}
-    {{if 'cudaSharedmemCarveoutMaxShared' in found_values}}
+    #: 1 channel unsigned 8-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized8X1 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized8X2' in found_values}}
 
-    #: Prefer maximum available shared memory, minimum L1 cache
-    cudaSharedmemCarveoutMaxShared = ccudart.cudaSharedCarveout.cudaSharedmemCarveoutMaxShared{{endif}}
-    {{if 'cudaSharedmemCarveoutMaxL1' in found_values}}
+    #: 2 channel unsigned 8-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized8X2 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized8X4' in found_values}}
 
-    #: Prefer maximum available L1 cache, minimum shared memory
-    cudaSharedmemCarveoutMaxL1 = ccudart.cudaSharedCarveout.cudaSharedmemCarveoutMaxL1{{endif}}
-{{endif}}
-{{if 'cudaComputeMode' in found_types}}
+    #: 4 channel unsigned 8-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized8X4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized16X1' in found_values}}
 
-class cudaComputeMode(IntEnum):
-    """
-    CUDA device compute modes
-    """
-    {{if 'cudaComputeModeDefault' in found_values}}
+    #: 1 channel unsigned 16-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized16X1 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized16X2' in found_values}}
 
-    #: Default compute mode (Multiple threads can use
-    #: :py:obj:`~.cudaSetDevice()` with this device)
-    cudaComputeModeDefault = ccudart.cudaComputeMode.cudaComputeModeDefault{{endif}}
-    {{if 'cudaComputeModeExclusive' in found_values}}
+    #: 2 channel unsigned 16-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized16X2 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedNormalized16X4' in found_values}}
 
-    #: Compute-exclusive-thread mode (Only one thread in one process will
-    #: be able to use :py:obj:`~.cudaSetDevice()` with this device)
-    cudaComputeModeExclusive = ccudart.cudaComputeMode.cudaComputeModeExclusive{{endif}}
-    {{if 'cudaComputeModeProhibited' in found_values}}
+    #: 4 channel unsigned 16-bit normalized integer
+    cudaChannelFormatKindUnsignedNormalized16X4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized8X1' in found_values}}
 
-    #: Compute-prohibited mode (No threads can use
-    #: :py:obj:`~.cudaSetDevice()` with this device)
-    cudaComputeModeProhibited = ccudart.cudaComputeMode.cudaComputeModeProhibited{{endif}}
-    {{if 'cudaComputeModeExclusiveProcess' in found_values}}
+    #: 1 channel signed 8-bit normalized integer
+    cudaChannelFormatKindSignedNormalized8X1 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized8X2' in found_values}}
 
-    #: Compute-exclusive-process mode (Many threads in one process will be
-    #: able to use :py:obj:`~.cudaSetDevice()` with this device)
-    cudaComputeModeExclusiveProcess = ccudart.cudaComputeMode.cudaComputeModeExclusiveProcess{{endif}}
-{{endif}}
-{{if 'cudaLimit' in found_types}}
+    #: 2 channel signed 8-bit normalized integer
+    cudaChannelFormatKindSignedNormalized8X2 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized8X4' in found_values}}
 
-class cudaLimit(IntEnum):
-    """
-    CUDA Limits
-    """
-    {{if 'cudaLimitStackSize' in found_values}}
+    #: 4 channel signed 8-bit normalized integer
+    cudaChannelFormatKindSignedNormalized8X4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized16X1' in found_values}}
 
-    #: GPU thread stack size
-    cudaLimitStackSize = ccudart.cudaLimit.cudaLimitStackSize{{endif}}
-    {{if 'cudaLimitPrintfFifoSize' in found_values}}
+    #: 1 channel signed 16-bit normalized integer
+    cudaChannelFormatKindSignedNormalized16X1 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized16X2' in found_values}}
 
-    #: GPU printf FIFO size
-    cudaLimitPrintfFifoSize = ccudart.cudaLimit.cudaLimitPrintfFifoSize{{endif}}
-    {{if 'cudaLimitMallocHeapSize' in found_values}}
+    #: 2 channel signed 16-bit normalized integer
+    cudaChannelFormatKindSignedNormalized16X2 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2{{endif}}
+    {{if 'cudaChannelFormatKindSignedNormalized16X4' in found_values}}
 
-    #: GPU malloc heap size
-    cudaLimitMallocHeapSize = ccudart.cudaLimit.cudaLimitMallocHeapSize{{endif}}
-    {{if 'cudaLimitDevRuntimeSyncDepth' in found_values}}
+    #: 4 channel signed 16-bit normalized integer
+    cudaChannelFormatKindSignedNormalized16X4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed1' in found_values}}
 
-    #: GPU device runtime synchronize depth
-    cudaLimitDevRuntimeSyncDepth = ccudart.cudaLimit.cudaLimitDevRuntimeSyncDepth{{endif}}
-    {{if 'cudaLimitDevRuntimePendingLaunchCount' in found_values}}
+    #: 4 channel unsigned normalized block-compressed (BC1 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed1 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed1SRGB' in found_values}}
 
-    #: GPU device runtime pending launch count
-    cudaLimitDevRuntimePendingLaunchCount = ccudart.cudaLimit.cudaLimitDevRuntimePendingLaunchCount{{endif}}
-    {{if 'cudaLimitMaxL2FetchGranularity' in found_values}}
+    #: 4 channel unsigned normalized block-compressed (BC1 compression)
+    #: format with sRGB encoding
+    cudaChannelFormatKindUnsignedBlockCompressed1SRGB = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed2' in found_values}}
 
-    #: A value between 0 and 128 that indicates the maximum fetch
-    #: granularity of L2 (in Bytes). This is a hint
-    cudaLimitMaxL2FetchGranularity = ccudart.cudaLimit.cudaLimitMaxL2FetchGranularity{{endif}}
-    {{if 'cudaLimitPersistingL2CacheSize' in found_values}}
+    #: 4 channel unsigned normalized block-compressed (BC2 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed2 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed2SRGB' in found_values}}
 
-    #: A size in bytes for L2 persisting lines cache size
-    cudaLimitPersistingL2CacheSize = ccudart.cudaLimit.cudaLimitPersistingL2CacheSize{{endif}}
-{{endif}}
-{{if 'cudaMemoryAdvise' in found_types}}
+    #: 4 channel unsigned normalized block-compressed (BC2 compression)
+    #: format with sRGB encoding
+    cudaChannelFormatKindUnsignedBlockCompressed2SRGB = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed3' in found_values}}
 
-class cudaMemoryAdvise(IntEnum):
-    """
-    CUDA Memory Advise values
-    """
-    {{if 'cudaMemAdviseSetReadMostly' in found_values}}
+    #: 4 channel unsigned normalized block-compressed (BC3 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed3 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed3SRGB' in found_values}}
 
-    #: Data will mostly be read and only occassionally be written to
-    cudaMemAdviseSetReadMostly = ccudart.cudaMemoryAdvise.cudaMemAdviseSetReadMostly{{endif}}
-    {{if 'cudaMemAdviseUnsetReadMostly' in found_values}}
+    #: 4 channel unsigned normalized block-compressed (BC3 compression)
+    #: format with sRGB encoding
+    cudaChannelFormatKindUnsignedBlockCompressed3SRGB = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed4' in found_values}}
 
-    #: Undo the effect of :py:obj:`~.cudaMemAdviseSetReadMostly`
-    cudaMemAdviseUnsetReadMostly = ccudart.cudaMemoryAdvise.cudaMemAdviseUnsetReadMostly{{endif}}
-    {{if 'cudaMemAdviseSetPreferredLocation' in found_values}}
+    #: 1 channel unsigned normalized block-compressed (BC4 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4{{endif}}
+    {{if 'cudaChannelFormatKindSignedBlockCompressed4' in found_values}}
 
-    #: Set the preferred location for the data as the specified device
-    cudaMemAdviseSetPreferredLocation = ccudart.cudaMemoryAdvise.cudaMemAdviseSetPreferredLocation{{endif}}
-    {{if 'cudaMemAdviseUnsetPreferredLocation' in found_values}}
+    #: 1 channel signed normalized block-compressed (BC4 compression)
+    #: format
+    cudaChannelFormatKindSignedBlockCompressed4 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed5' in found_values}}
 
-    #: Clear the preferred location for the data
-    cudaMemAdviseUnsetPreferredLocation = ccudart.cudaMemoryAdvise.cudaMemAdviseUnsetPreferredLocation{{endif}}
-    {{if 'cudaMemAdviseSetAccessedBy' in found_values}}
+    #: 2 channel unsigned normalized block-compressed (BC5 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed5 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5{{endif}}
+    {{if 'cudaChannelFormatKindSignedBlockCompressed5' in found_values}}
 
-    #: Data will be accessed by the specified device, so prevent page
-    #: faults as much as possible
-    cudaMemAdviseSetAccessedBy = ccudart.cudaMemoryAdvise.cudaMemAdviseSetAccessedBy{{endif}}
-    {{if 'cudaMemAdviseUnsetAccessedBy' in found_values}}
+    #: 2 channel signed normalized block-compressed (BC5 compression)
+    #: format
+    cudaChannelFormatKindSignedBlockCompressed5 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed6H' in found_values}}
 
-    #: Let the Unified Memory subsystem decide on the page faulting policy
-    #: for the specified device
-    cudaMemAdviseUnsetAccessedBy = ccudart.cudaMemoryAdvise.cudaMemAdviseUnsetAccessedBy{{endif}}
+    #: 3 channel unsigned half-float block-compressed (BC6H compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed6H = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H{{endif}}
+    {{if 'cudaChannelFormatKindSignedBlockCompressed6H' in found_values}}
+
+    #: 3 channel signed half-float block-compressed (BC6H compression)
+    #: format
+    cudaChannelFormatKindSignedBlockCompressed6H = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed7' in found_values}}
+
+    #: 4 channel unsigned normalized block-compressed (BC7 compression)
+    #: format
+    cudaChannelFormatKindUnsignedBlockCompressed7 = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7{{endif}}
+    {{if 'cudaChannelFormatKindUnsignedBlockCompressed7SRGB' in found_values}}
+
+    #: 4 channel unsigned normalized block-compressed (BC7 compression)
+    #: format with sRGB encoding
+    cudaChannelFormatKindUnsignedBlockCompressed7SRGB = cyruntime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB{{endif}}
 {{endif}}
-{{if 'cudaMemRangeAttribute' in found_types}}
+{{if 'cudaMemoryType' in found_types}}
 
-class cudaMemRangeAttribute(IntEnum):
+class cudaMemoryType(IntEnum):
     """
-    CUDA range attributes
+    CUDA memory types
     """
-    {{if 'cudaMemRangeAttributeReadMostly' in found_values}}
+    {{if 'cudaMemoryTypeUnregistered' in found_values}}
 
-    #: Whether the range will mostly be read and only occassionally be
-    #: written to
-    cudaMemRangeAttributeReadMostly = ccudart.cudaMemRangeAttribute.cudaMemRangeAttributeReadMostly{{endif}}
-    {{if 'cudaMemRangeAttributePreferredLocation' in found_values}}
+    #: Unregistered memory
+    cudaMemoryTypeUnregistered = cyruntime.cudaMemoryType.cudaMemoryTypeUnregistered{{endif}}
+    {{if 'cudaMemoryTypeHost' in found_values}}
 
-    #: The preferred location of the range
-    cudaMemRangeAttributePreferredLocation = ccudart.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocation{{endif}}
-    {{if 'cudaMemRangeAttributeAccessedBy' in found_values}}
+    #: Host memory
+    cudaMemoryTypeHost = cyruntime.cudaMemoryType.cudaMemoryTypeHost{{endif}}
+    {{if 'cudaMemoryTypeDevice' in found_values}}
 
-    #: Memory range has :py:obj:`~.cudaMemAdviseSetAccessedBy` set for
-    #: specified device
-    cudaMemRangeAttributeAccessedBy = ccudart.cudaMemRangeAttribute.cudaMemRangeAttributeAccessedBy{{endif}}
-    {{if 'cudaMemRangeAttributeLastPrefetchLocation' in found_values}}
+    #: Device memory
+    cudaMemoryTypeDevice = cyruntime.cudaMemoryType.cudaMemoryTypeDevice{{endif}}
+    {{if 'cudaMemoryTypeManaged' in found_values}}
 
-    #: The last location to which the range was prefetched
-    cudaMemRangeAttributeLastPrefetchLocation = ccudart.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocation{{endif}}
+    #: Managed memory
+    cudaMemoryTypeManaged = cyruntime.cudaMemoryType.cudaMemoryTypeManaged{{endif}}
 {{endif}}
-{{if 'cudaOutputMode' in found_types}}
+{{if 'cudaMemcpyKind' in found_types}}
 
-class cudaOutputMode_t(IntEnum):
+class cudaMemcpyKind(IntEnum):
     """
-    CUDA Profiler Output modes
+    CUDA memory copy types
     """
-    {{if 'cudaKeyValuePair' in found_values}}
+    {{if 'cudaMemcpyHostToHost' in found_values}}
 
-    #: Output mode Key-Value pair format.
-    cudaKeyValuePair = ccudart.cudaOutputMode.cudaKeyValuePair{{endif}}
-    {{if 'cudaCSV' in found_values}}
+    #: Host -> Host
+    cudaMemcpyHostToHost = cyruntime.cudaMemcpyKind.cudaMemcpyHostToHost{{endif}}
+    {{if 'cudaMemcpyHostToDevice' in found_values}}
 
-    #: Output mode Comma separated values format.
-    cudaCSV = ccudart.cudaOutputMode.cudaCSV{{endif}}
-{{endif}}
-{{if 'cudaFlushGPUDirectRDMAWritesOptions' in found_types}}
+    #: Host -> Device
+    cudaMemcpyHostToDevice = cyruntime.cudaMemcpyKind.cudaMemcpyHostToDevice{{endif}}
+    {{if 'cudaMemcpyDeviceToHost' in found_values}}
 
-class cudaFlushGPUDirectRDMAWritesOptions(IntEnum):
-    """
-    CUDA GPUDirect RDMA flush writes APIs supported on the device
-    """
-    {{if 'cudaFlushGPUDirectRDMAWritesOptionHost' in found_values}}
+    #: Device -> Host
+    cudaMemcpyDeviceToHost = cyruntime.cudaMemcpyKind.cudaMemcpyDeviceToHost{{endif}}
+    {{if 'cudaMemcpyDeviceToDevice' in found_values}}
 
-    #: :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` and its CUDA Driver
-    #: API counterpart are supported on the device.
-    cudaFlushGPUDirectRDMAWritesOptionHost = ccudart.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionHost{{endif}}
-    {{if 'cudaFlushGPUDirectRDMAWritesOptionMemOps' in found_values}}
+    #: Device -> Device
+    cudaMemcpyDeviceToDevice = cyruntime.cudaMemcpyKind.cudaMemcpyDeviceToDevice{{endif}}
+    {{if 'cudaMemcpyDefault' in found_values}}
 
-    #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the
-    #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
-    #: on the CUDA device.
-    cudaFlushGPUDirectRDMAWritesOptionMemOps = ccudart.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionMemOps{{endif}}
+    #: Direction of the transfer is inferred from the pointer values.
+    #: Requires unified virtual addressing
+    cudaMemcpyDefault = cyruntime.cudaMemcpyKind.cudaMemcpyDefault{{endif}}
 {{endif}}
-{{if 'cudaGPUDirectRDMAWritesOrdering' in found_types}}
+{{if 'cudaAccessProperty' in found_types}}
 
-class cudaGPUDirectRDMAWritesOrdering(IntEnum):
+class cudaAccessProperty(IntEnum):
     """
-    CUDA GPUDirect RDMA flush writes ordering features of the device
+    Specifies performance hint with :py:obj:`~.cudaAccessPolicyWindow`
+    for hitProp and missProp members.
     """
-    {{if 'cudaGPUDirectRDMAWritesOrderingNone' in found_values}}
+    {{if 'cudaAccessPropertyNormal' in found_values}}
 
-    #: The device does not natively support ordering of GPUDirect RDMA
-    #: writes. :py:obj:`~.cudaFlushGPUDirectRDMAWrites()` can be leveraged
-    #: if supported.
-    cudaGPUDirectRDMAWritesOrderingNone = ccudart.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingNone{{endif}}
-    {{if 'cudaGPUDirectRDMAWritesOrderingOwner' in found_values}}
+    #: Normal cache persistence.
+    cudaAccessPropertyNormal = cyruntime.cudaAccessProperty.cudaAccessPropertyNormal{{endif}}
+    {{if 'cudaAccessPropertyStreaming' in found_values}}
 
-    #: Natively, the device can consistently consume GPUDirect RDMA writes,
-    #: although other CUDA devices may not.
-    cudaGPUDirectRDMAWritesOrderingOwner = ccudart.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingOwner{{endif}}
-    {{if 'cudaGPUDirectRDMAWritesOrderingAllDevices' in found_values}}
+    #: Streaming access is less likely to persit from cache.
+    cudaAccessPropertyStreaming = cyruntime.cudaAccessProperty.cudaAccessPropertyStreaming{{endif}}
+    {{if 'cudaAccessPropertyPersisting' in found_values}}
 
-    #: Any CUDA device in the system can consistently consume GPUDirect
-    #: RDMA writes to this device.
-    cudaGPUDirectRDMAWritesOrderingAllDevices = ccudart.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingAllDevices{{endif}}
+    #: Persisting access is more likely to persist in cache.
+    cudaAccessPropertyPersisting = cyruntime.cudaAccessProperty.cudaAccessPropertyPersisting{{endif}}
 {{endif}}
-{{if 'cudaFlushGPUDirectRDMAWritesScope' in found_types}}
+{{if 'cudaStreamCaptureStatus' in found_types}}
 
-class cudaFlushGPUDirectRDMAWritesScope(IntEnum):
+class cudaStreamCaptureStatus(IntEnum):
     """
-    CUDA GPUDirect RDMA flush writes scopes
+    Possible stream capture statuses returned by
+    :py:obj:`~.cudaStreamIsCapturing`
     """
-    {{if 'cudaFlushGPUDirectRDMAWritesToOwner' in found_values}}
+    {{if 'cudaStreamCaptureStatusNone' in found_values}}
 
-    #: Blocks until remote writes are visible to the CUDA device context
-    #: owning the data.
-    cudaFlushGPUDirectRDMAWritesToOwner = ccudart.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToOwner{{endif}}
-    {{if 'cudaFlushGPUDirectRDMAWritesToAllDevices' in found_values}}
+    #: Stream is not capturing
+    cudaStreamCaptureStatusNone = cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusNone{{endif}}
+    {{if 'cudaStreamCaptureStatusActive' in found_values}}
 
-    #: Blocks until remote writes are visible to all CUDA device contexts.
-    cudaFlushGPUDirectRDMAWritesToAllDevices = ccudart.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToAllDevices{{endif}}
+    #: Stream is actively capturing
+    cudaStreamCaptureStatusActive = cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusActive{{endif}}
+    {{if 'cudaStreamCaptureStatusInvalidated' in found_values}}
+
+    #: Stream is part of a capture sequence that has been invalidated, but
+    #: not terminated
+    cudaStreamCaptureStatusInvalidated = cyruntime.cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated{{endif}}
 {{endif}}
-{{if 'cudaFlushGPUDirectRDMAWritesTarget' in found_types}}
+{{if 'cudaStreamCaptureMode' in found_types}}
 
-class cudaFlushGPUDirectRDMAWritesTarget(IntEnum):
+class cudaStreamCaptureMode(IntEnum):
     """
-    CUDA GPUDirect RDMA flush writes targets
+    Possible modes for stream capture thread interactions. For more
+    details see :py:obj:`~.cudaStreamBeginCapture` and
+    :py:obj:`~.cudaThreadExchangeStreamCaptureMode`
     """
-    {{if 'cudaFlushGPUDirectRDMAWritesTargetCurrentDevice' in found_values}}
+    {{if 'cudaStreamCaptureModeGlobal' in found_values}}
+    cudaStreamCaptureModeGlobal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeGlobal{{endif}}
+    {{if 'cudaStreamCaptureModeThreadLocal' in found_values}}
+    cudaStreamCaptureModeThreadLocal = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal{{endif}}
+    {{if 'cudaStreamCaptureModeRelaxed' in found_values}}
+    cudaStreamCaptureModeRelaxed = cyruntime.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed{{endif}}
+{{endif}}
+{{if 'cudaSynchronizationPolicy' in found_types}}
 
-    #: Sets the target for :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()`
-    #: to the currently active CUDA device context.
-    cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = ccudart.cudaFlushGPUDirectRDMAWritesTarget.cudaFlushGPUDirectRDMAWritesTargetCurrentDevice{{endif}}
+class cudaSynchronizationPolicy(IntEnum):
+    """
+
+    """
+    {{if 'cudaSyncPolicyAuto' in found_values}}
+    cudaSyncPolicyAuto = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyAuto{{endif}}
+    {{if 'cudaSyncPolicySpin' in found_values}}
+    cudaSyncPolicySpin = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicySpin{{endif}}
+    {{if 'cudaSyncPolicyYield' in found_values}}
+    cudaSyncPolicyYield = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyYield{{endif}}
+    {{if 'cudaSyncPolicyBlockingSync' in found_values}}
+    cudaSyncPolicyBlockingSync = cyruntime.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync{{endif}}
 {{endif}}
-{{if 'cudaDeviceAttr' in found_types}}
+{{if 'cudaClusterSchedulingPolicy' in found_types}}
 
-class cudaDeviceAttr(IntEnum):
+class cudaClusterSchedulingPolicy(IntEnum):
     """
-    CUDA device attributes
+    Cluster scheduling policies. These may be passed to
+    :py:obj:`~.cudaFuncSetAttribute`
     """
-    {{if 'cudaDevAttrMaxThreadsPerBlock' in found_values}}
+    {{if 'cudaClusterSchedulingPolicyDefault' in found_values}}
 
-    #: Maximum number of threads per block
-    cudaDevAttrMaxThreadsPerBlock = ccudart.cudaDeviceAttr.cudaDevAttrMaxThreadsPerBlock{{endif}}
-    {{if 'cudaDevAttrMaxBlockDimX' in found_values}}
+    #: the default policy
+    cudaClusterSchedulingPolicyDefault = cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyDefault{{endif}}
+    {{if 'cudaClusterSchedulingPolicySpread' in found_values}}
 
-    #: Maximum block dimension X
-    cudaDevAttrMaxBlockDimX = ccudart.cudaDeviceAttr.cudaDevAttrMaxBlockDimX{{endif}}
-    {{if 'cudaDevAttrMaxBlockDimY' in found_values}}
+    #: spread the blocks within a cluster to the SMs
+    cudaClusterSchedulingPolicySpread = cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicySpread{{endif}}
+    {{if 'cudaClusterSchedulingPolicyLoadBalancing' in found_values}}
 
-    #: Maximum block dimension Y
-    cudaDevAttrMaxBlockDimY = ccudart.cudaDeviceAttr.cudaDevAttrMaxBlockDimY{{endif}}
-    {{if 'cudaDevAttrMaxBlockDimZ' in found_values}}
+    #: allow the hardware to load-balance the blocks in a cluster to the
+    #: SMs
+    cudaClusterSchedulingPolicyLoadBalancing = cyruntime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyLoadBalancing{{endif}}
+{{endif}}
+{{if 'cudaStreamUpdateCaptureDependenciesFlags' in found_types}}
 
-    #: Maximum block dimension Z
-    cudaDevAttrMaxBlockDimZ = ccudart.cudaDeviceAttr.cudaDevAttrMaxBlockDimZ{{endif}}
-    {{if 'cudaDevAttrMaxGridDimX' in found_values}}
+class cudaStreamUpdateCaptureDependenciesFlags(IntEnum):
+    """
+    Flags for :py:obj:`~.cudaStreamUpdateCaptureDependencies`
+    """
+    {{if 'cudaStreamAddCaptureDependencies' in found_values}}
 
-    #: Maximum grid dimension X
-    cudaDevAttrMaxGridDimX = ccudart.cudaDeviceAttr.cudaDevAttrMaxGridDimX{{endif}}
-    {{if 'cudaDevAttrMaxGridDimY' in found_values}}
+    #: Add new nodes to the dependency set
+    cudaStreamAddCaptureDependencies = cyruntime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamAddCaptureDependencies{{endif}}
+    {{if 'cudaStreamSetCaptureDependencies' in found_values}}
 
-    #: Maximum grid dimension Y
-    cudaDevAttrMaxGridDimY = ccudart.cudaDeviceAttr.cudaDevAttrMaxGridDimY{{endif}}
-    {{if 'cudaDevAttrMaxGridDimZ' in found_values}}
+    #: Replace the dependency set with the new nodes
+    cudaStreamSetCaptureDependencies = cyruntime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamSetCaptureDependencies{{endif}}
+{{endif}}
+{{if 'cudaUserObjectFlags' in found_types}}
 
-    #: Maximum grid dimension Z
-    cudaDevAttrMaxGridDimZ = ccudart.cudaDeviceAttr.cudaDevAttrMaxGridDimZ{{endif}}
-    {{if 'cudaDevAttrMaxSharedMemoryPerBlock' in found_values}}
+class cudaUserObjectFlags(IntEnum):
+    """
+    Flags for user objects for graphs
+    """
+    {{if 'cudaUserObjectNoDestructorSync' in found_values}}
 
-    #: Maximum shared memory available per block in bytes
-    cudaDevAttrMaxSharedMemoryPerBlock = ccudart.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlock{{endif}}
-    {{if 'cudaDevAttrTotalConstantMemory' in found_values}}
+    #: Indicates the destructor execution is not synchronized by any CUDA
+    #: handle.
+    cudaUserObjectNoDestructorSync = cyruntime.cudaUserObjectFlags.cudaUserObjectNoDestructorSync{{endif}}
+{{endif}}
+{{if 'cudaUserObjectRetainFlags' in found_types}}
 
-    #: Memory available on device for constant variables in a CUDA C kernel
-    #: in bytes
-    cudaDevAttrTotalConstantMemory = ccudart.cudaDeviceAttr.cudaDevAttrTotalConstantMemory{{endif}}
-    {{if 'cudaDevAttrWarpSize' in found_values}}
+class cudaUserObjectRetainFlags(IntEnum):
+    """
+    Flags for retaining user object references for graphs
+    """
+    {{if 'cudaGraphUserObjectMove' in found_values}}
 
-    #: Warp size in threads
-    cudaDevAttrWarpSize = ccudart.cudaDeviceAttr.cudaDevAttrWarpSize{{endif}}
-    {{if 'cudaDevAttrMaxPitch' in found_values}}
+    #: Transfer references from the caller rather than creating new
+    #: references.
+    cudaGraphUserObjectMove = cyruntime.cudaUserObjectRetainFlags.cudaGraphUserObjectMove{{endif}}
+{{endif}}
+{{if 'cudaGraphicsRegisterFlags' in found_types}}
 
-    #: Maximum pitch in bytes allowed by memory copies
-    cudaDevAttrMaxPitch = ccudart.cudaDeviceAttr.cudaDevAttrMaxPitch{{endif}}
-    {{if 'cudaDevAttrMaxRegistersPerBlock' in found_values}}
+class cudaGraphicsRegisterFlags(IntEnum):
+    """
+    CUDA graphics interop register flags
+    """
+    {{if 'cudaGraphicsRegisterFlagsNone' in found_values}}
 
-    #: Maximum number of 32-bit registers available per block
-    cudaDevAttrMaxRegistersPerBlock = ccudart.cudaDeviceAttr.cudaDevAttrMaxRegistersPerBlock{{endif}}
-    {{if 'cudaDevAttrClockRate' in found_values}}
+    #: Default
+    cudaGraphicsRegisterFlagsNone = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsNone{{endif}}
+    {{if 'cudaGraphicsRegisterFlagsReadOnly' in found_values}}
 
-    #: Peak clock frequency in kilohertz
-    cudaDevAttrClockRate = ccudart.cudaDeviceAttr.cudaDevAttrClockRate{{endif}}
-    {{if 'cudaDevAttrTextureAlignment' in found_values}}
+    #: CUDA will not write to this resource
+    cudaGraphicsRegisterFlagsReadOnly = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsReadOnly{{endif}}
+    {{if 'cudaGraphicsRegisterFlagsWriteDiscard' in found_values}}
 
-    #: Alignment requirement for textures
-    cudaDevAttrTextureAlignment = ccudart.cudaDeviceAttr.cudaDevAttrTextureAlignment{{endif}}
-    {{if 'cudaDevAttrGpuOverlap' in found_values}}
+    #: CUDA will only write to and will not read from this resource
+    cudaGraphicsRegisterFlagsWriteDiscard = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsWriteDiscard{{endif}}
+    {{if 'cudaGraphicsRegisterFlagsSurfaceLoadStore' in found_values}}
 
-    #: Device can possibly copy memory and execute a kernel concurrently
-    cudaDevAttrGpuOverlap = ccudart.cudaDeviceAttr.cudaDevAttrGpuOverlap{{endif}}
-    {{if 'cudaDevAttrMultiProcessorCount' in found_values}}
+    #: CUDA will bind this resource to a surface reference
+    cudaGraphicsRegisterFlagsSurfaceLoadStore = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsSurfaceLoadStore{{endif}}
+    {{if 'cudaGraphicsRegisterFlagsTextureGather' in found_values}}
 
-    #: Number of multiprocessors on device
-    cudaDevAttrMultiProcessorCount = ccudart.cudaDeviceAttr.cudaDevAttrMultiProcessorCount{{endif}}
-    {{if 'cudaDevAttrKernelExecTimeout' in found_values}}
+    #: CUDA will perform texture gather operations on this resource
+    cudaGraphicsRegisterFlagsTextureGather = cyruntime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsTextureGather{{endif}}
+{{endif}}
+{{if 'cudaGraphicsMapFlags' in found_types}}
 
-    #: Specifies whether there is a run time limit on kernels
-    cudaDevAttrKernelExecTimeout = ccudart.cudaDeviceAttr.cudaDevAttrKernelExecTimeout{{endif}}
-    {{if 'cudaDevAttrIntegrated' in found_values}}
+class cudaGraphicsMapFlags(IntEnum):
+    """
+    CUDA graphics interop map flags
+    """
+    {{if 'cudaGraphicsMapFlagsNone' in found_values}}
 
-    #: Device is integrated with host memory
-    cudaDevAttrIntegrated = ccudart.cudaDeviceAttr.cudaDevAttrIntegrated{{endif}}
-    {{if 'cudaDevAttrCanMapHostMemory' in found_values}}
+    #: Default; Assume resource can be read/written
+    cudaGraphicsMapFlagsNone = cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsNone{{endif}}
+    {{if 'cudaGraphicsMapFlagsReadOnly' in found_values}}
 
-    #: Device can map host memory into CUDA address space
-    cudaDevAttrCanMapHostMemory = ccudart.cudaDeviceAttr.cudaDevAttrCanMapHostMemory{{endif}}
-    {{if 'cudaDevAttrComputeMode' in found_values}}
+    #: CUDA will not write to this resource
+    cudaGraphicsMapFlagsReadOnly = cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsReadOnly{{endif}}
+    {{if 'cudaGraphicsMapFlagsWriteDiscard' in found_values}}
 
-    #: Compute mode (See :py:obj:`~.cudaComputeMode` for details)
-    cudaDevAttrComputeMode = ccudart.cudaDeviceAttr.cudaDevAttrComputeMode{{endif}}
-    {{if 'cudaDevAttrMaxTexture1DWidth' in found_values}}
+    #: CUDA will only write to and will not read from this resource
+    cudaGraphicsMapFlagsWriteDiscard = cyruntime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsWriteDiscard{{endif}}
+{{endif}}
+{{if 'cudaGraphicsCubeFace' in found_types}}
 
-    #: Maximum 1D texture width
-    cudaDevAttrMaxTexture1DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture1DWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DWidth' in found_values}}
+class cudaGraphicsCubeFace(IntEnum):
+    """
+    CUDA graphics interop array indices for cube maps
+    """
+    {{if 'cudaGraphicsCubeFacePositiveX' in found_values}}
 
-    #: Maximum 2D texture width
-    cudaDevAttrMaxTexture2DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DHeight' in found_values}}
+    #: Positive X face of cubemap
+    cudaGraphicsCubeFacePositiveX = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveX{{endif}}
+    {{if 'cudaGraphicsCubeFaceNegativeX' in found_values}}
 
-    #: Maximum 2D texture height
-    cudaDevAttrMaxTexture2DHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DHeight{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DWidth' in found_values}}
+    #: Negative X face of cubemap
+    cudaGraphicsCubeFaceNegativeX = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeX{{endif}}
+    {{if 'cudaGraphicsCubeFacePositiveY' in found_values}}
 
-    #: Maximum 3D texture width
-    cudaDevAttrMaxTexture3DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DHeight' in found_values}}
+    #: Positive Y face of cubemap
+    cudaGraphicsCubeFacePositiveY = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveY{{endif}}
+    {{if 'cudaGraphicsCubeFaceNegativeY' in found_values}}
 
-    #: Maximum 3D texture height
-    cudaDevAttrMaxTexture3DHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeight{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DDepth' in found_values}}
+    #: Negative Y face of cubemap
+    cudaGraphicsCubeFaceNegativeY = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeY{{endif}}
+    {{if 'cudaGraphicsCubeFacePositiveZ' in found_values}}
 
-    #: Maximum 3D texture depth
-    cudaDevAttrMaxTexture3DDepth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLayeredWidth' in found_values}}
+    #: Positive Z face of cubemap
+    cudaGraphicsCubeFacePositiveZ = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveZ{{endif}}
+    {{if 'cudaGraphicsCubeFaceNegativeZ' in found_values}}
 
-    #: Maximum 2D layered texture width
-    cudaDevAttrMaxTexture2DLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLayeredHeight' in found_values}}
+    #: Negative Z face of cubemap
+    cudaGraphicsCubeFaceNegativeZ = cyruntime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeZ{{endif}}
+{{endif}}
+{{if 'cudaResourceType' in found_types}}
 
-    #: Maximum 2D layered texture height
-    cudaDevAttrMaxTexture2DLayeredHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredHeight{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLayeredLayers' in found_values}}
+class cudaResourceType(IntEnum):
+    """
+    CUDA resource types
+    """
+    {{if 'cudaResourceTypeArray' in found_values}}
 
-    #: Maximum layers in a 2D layered texture
-    cudaDevAttrMaxTexture2DLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredLayers{{endif}}
-    {{if 'cudaDevAttrSurfaceAlignment' in found_values}}
+    #: Array resource
+    cudaResourceTypeArray = cyruntime.cudaResourceType.cudaResourceTypeArray{{endif}}
+    {{if 'cudaResourceTypeMipmappedArray' in found_values}}
 
-    #: Alignment requirement for surfaces
-    cudaDevAttrSurfaceAlignment = ccudart.cudaDeviceAttr.cudaDevAttrSurfaceAlignment{{endif}}
-    {{if 'cudaDevAttrConcurrentKernels' in found_values}}
+    #: Mipmapped array resource
+    cudaResourceTypeMipmappedArray = cyruntime.cudaResourceType.cudaResourceTypeMipmappedArray{{endif}}
+    {{if 'cudaResourceTypeLinear' in found_values}}
 
-    #: Device can possibly execute multiple kernels concurrently
-    cudaDevAttrConcurrentKernels = ccudart.cudaDeviceAttr.cudaDevAttrConcurrentKernels{{endif}}
-    {{if 'cudaDevAttrEccEnabled' in found_values}}
+    #: Linear resource
+    cudaResourceTypeLinear = cyruntime.cudaResourceType.cudaResourceTypeLinear{{endif}}
+    {{if 'cudaResourceTypePitch2D' in found_values}}
 
-    #: Device has ECC support enabled
-    cudaDevAttrEccEnabled = ccudart.cudaDeviceAttr.cudaDevAttrEccEnabled{{endif}}
-    {{if 'cudaDevAttrPciBusId' in found_values}}
+    #: Pitch 2D resource
+    cudaResourceTypePitch2D = cyruntime.cudaResourceType.cudaResourceTypePitch2D{{endif}}
+{{endif}}
+{{if 'cudaResourceViewFormat' in found_types}}
 
-    #: PCI bus ID of the device
-    cudaDevAttrPciBusId = ccudart.cudaDeviceAttr.cudaDevAttrPciBusId{{endif}}
-    {{if 'cudaDevAttrPciDeviceId' in found_values}}
+class cudaResourceViewFormat(IntEnum):
+    """
+    CUDA texture resource view formats
+    """
+    {{if 'cudaResViewFormatNone' in found_values}}
 
-    #: PCI device ID of the device
-    cudaDevAttrPciDeviceId = ccudart.cudaDeviceAttr.cudaDevAttrPciDeviceId{{endif}}
-    {{if 'cudaDevAttrTccDriver' in found_values}}
+    #: No resource view format (use underlying resource format)
+    cudaResViewFormatNone = cyruntime.cudaResourceViewFormat.cudaResViewFormatNone{{endif}}
+    {{if 'cudaResViewFormatUnsignedChar1' in found_values}}
 
-    #: Device is using TCC driver model
-    cudaDevAttrTccDriver = ccudart.cudaDeviceAttr.cudaDevAttrTccDriver{{endif}}
-    {{if 'cudaDevAttrMemoryClockRate' in found_values}}
+    #: 1 channel unsigned 8-bit integers
+    cudaResViewFormatUnsignedChar1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar1{{endif}}
+    {{if 'cudaResViewFormatUnsignedChar2' in found_values}}
 
-    #: Peak memory clock frequency in kilohertz
-    cudaDevAttrMemoryClockRate = ccudart.cudaDeviceAttr.cudaDevAttrMemoryClockRate{{endif}}
-    {{if 'cudaDevAttrGlobalMemoryBusWidth' in found_values}}
+    #: 2 channel unsigned 8-bit integers
+    cudaResViewFormatUnsignedChar2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar2{{endif}}
+    {{if 'cudaResViewFormatUnsignedChar4' in found_values}}
 
-    #: Global memory bus width in bits
-    cudaDevAttrGlobalMemoryBusWidth = ccudart.cudaDeviceAttr.cudaDevAttrGlobalMemoryBusWidth{{endif}}
-    {{if 'cudaDevAttrL2CacheSize' in found_values}}
+    #: 4 channel unsigned 8-bit integers
+    cudaResViewFormatUnsignedChar4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar4{{endif}}
+    {{if 'cudaResViewFormatSignedChar1' in found_values}}
 
-    #: Size of L2 cache in bytes
-    cudaDevAttrL2CacheSize = ccudart.cudaDeviceAttr.cudaDevAttrL2CacheSize{{endif}}
-    {{if 'cudaDevAttrMaxThreadsPerMultiProcessor' in found_values}}
+    #: 1 channel signed 8-bit integers
+    cudaResViewFormatSignedChar1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar1{{endif}}
+    {{if 'cudaResViewFormatSignedChar2' in found_values}}
 
-    #: Maximum resident threads per multiprocessor
-    cudaDevAttrMaxThreadsPerMultiProcessor = ccudart.cudaDeviceAttr.cudaDevAttrMaxThreadsPerMultiProcessor{{endif}}
-    {{if 'cudaDevAttrAsyncEngineCount' in found_values}}
+    #: 2 channel signed 8-bit integers
+    cudaResViewFormatSignedChar2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar2{{endif}}
+    {{if 'cudaResViewFormatSignedChar4' in found_values}}
 
-    #: Number of asynchronous engines
-    cudaDevAttrAsyncEngineCount = ccudart.cudaDeviceAttr.cudaDevAttrAsyncEngineCount{{endif}}
-    {{if 'cudaDevAttrUnifiedAddressing' in found_values}}
+    #: 4 channel signed 8-bit integers
+    cudaResViewFormatSignedChar4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedChar4{{endif}}
+    {{if 'cudaResViewFormatUnsignedShort1' in found_values}}
 
-    #: Device shares a unified address space with the host
-    cudaDevAttrUnifiedAddressing = ccudart.cudaDeviceAttr.cudaDevAttrUnifiedAddressing{{endif}}
-    {{if 'cudaDevAttrMaxTexture1DLayeredWidth' in found_values}}
+    #: 1 channel unsigned 16-bit integers
+    cudaResViewFormatUnsignedShort1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort1{{endif}}
+    {{if 'cudaResViewFormatUnsignedShort2' in found_values}}
 
-    #: Maximum 1D layered texture width
-    cudaDevAttrMaxTexture1DLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture1DLayeredLayers' in found_values}}
+    #: 2 channel unsigned 16-bit integers
+    cudaResViewFormatUnsignedShort2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort2{{endif}}
+    {{if 'cudaResViewFormatUnsignedShort4' in found_values}}
 
-    #: Maximum layers in a 1D layered texture
-    cudaDevAttrMaxTexture1DLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredLayers{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DGatherWidth' in found_values}}
+    #: 4 channel unsigned 16-bit integers
+    cudaResViewFormatUnsignedShort4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort4{{endif}}
+    {{if 'cudaResViewFormatSignedShort1' in found_values}}
 
-    #: Maximum 2D texture width if cudaArrayTextureGather is set
-    cudaDevAttrMaxTexture2DGatherWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DGatherHeight' in found_values}}
+    #: 1 channel signed 16-bit integers
+    cudaResViewFormatSignedShort1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort1{{endif}}
+    {{if 'cudaResViewFormatSignedShort2' in found_values}}
 
-    #: Maximum 2D texture height if cudaArrayTextureGather is set
-    cudaDevAttrMaxTexture2DGatherHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherHeight{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DWidthAlt' in found_values}}
+    #: 2 channel signed 16-bit integers
+    cudaResViewFormatSignedShort2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort2{{endif}}
+    {{if 'cudaResViewFormatSignedShort4' in found_values}}
 
-    #: Alternate maximum 3D texture width
-    cudaDevAttrMaxTexture3DWidthAlt = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidthAlt{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DHeightAlt' in found_values}}
+    #: 4 channel signed 16-bit integers
+    cudaResViewFormatSignedShort4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedShort4{{endif}}
+    {{if 'cudaResViewFormatUnsignedInt1' in found_values}}
 
-    #: Alternate maximum 3D texture height
-    cudaDevAttrMaxTexture3DHeightAlt = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeightAlt{{endif}}
-    {{if 'cudaDevAttrMaxTexture3DDepthAlt' in found_values}}
+    #: 1 channel unsigned 32-bit integers
+    cudaResViewFormatUnsignedInt1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt1{{endif}}
+    {{if 'cudaResViewFormatUnsignedInt2' in found_values}}
 
-    #: Alternate maximum 3D texture depth
-    cudaDevAttrMaxTexture3DDepthAlt = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepthAlt{{endif}}
-    {{if 'cudaDevAttrPciDomainId' in found_values}}
+    #: 2 channel unsigned 32-bit integers
+    cudaResViewFormatUnsignedInt2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt2{{endif}}
+    {{if 'cudaResViewFormatUnsignedInt4' in found_values}}
 
-    #: PCI domain ID of the device
-    cudaDevAttrPciDomainId = ccudart.cudaDeviceAttr.cudaDevAttrPciDomainId{{endif}}
-    {{if 'cudaDevAttrTexturePitchAlignment' in found_values}}
+    #: 4 channel unsigned 32-bit integers
+    cudaResViewFormatUnsignedInt4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt4{{endif}}
+    {{if 'cudaResViewFormatSignedInt1' in found_values}}
 
-    #: Pitch alignment requirement for textures
-    cudaDevAttrTexturePitchAlignment = ccudart.cudaDeviceAttr.cudaDevAttrTexturePitchAlignment{{endif}}
-    {{if 'cudaDevAttrMaxTextureCubemapWidth' in found_values}}
+    #: 1 channel signed 32-bit integers
+    cudaResViewFormatSignedInt1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt1{{endif}}
+    {{if 'cudaResViewFormatSignedInt2' in found_values}}
 
-    #: Maximum cubemap texture width/height
-    cudaDevAttrMaxTextureCubemapWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapWidth{{endif}}
-    {{if 'cudaDevAttrMaxTextureCubemapLayeredWidth' in found_values}}
+    #: 2 channel signed 32-bit integers
+    cudaResViewFormatSignedInt2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt2{{endif}}
+    {{if 'cudaResViewFormatSignedInt4' in found_values}}
 
-    #: Maximum cubemap layered texture width/height
-    cudaDevAttrMaxTextureCubemapLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxTextureCubemapLayeredLayers' in found_values}}
+    #: 4 channel signed 32-bit integers
+    cudaResViewFormatSignedInt4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedInt4{{endif}}
+    {{if 'cudaResViewFormatHalf1' in found_values}}
 
-    #: Maximum layers in a cubemap layered texture
-    cudaDevAttrMaxTextureCubemapLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredLayers{{endif}}
-    {{if 'cudaDevAttrMaxSurface1DWidth' in found_values}}
+    #: 1 channel 16-bit floating point
+    cudaResViewFormatHalf1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf1{{endif}}
+    {{if 'cudaResViewFormatHalf2' in found_values}}
 
-    #: Maximum 1D surface width
-    cudaDevAttrMaxSurface1DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface1DWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurface2DWidth' in found_values}}
+    #: 2 channel 16-bit floating point
+    cudaResViewFormatHalf2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf2{{endif}}
+    {{if 'cudaResViewFormatHalf4' in found_values}}
 
-    #: Maximum 2D surface width
-    cudaDevAttrMaxSurface2DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface2DWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurface2DHeight' in found_values}}
+    #: 4 channel 16-bit floating point
+    cudaResViewFormatHalf4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatHalf4{{endif}}
+    {{if 'cudaResViewFormatFloat1' in found_values}}
 
-    #: Maximum 2D surface height
-    cudaDevAttrMaxSurface2DHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface2DHeight{{endif}}
-    {{if 'cudaDevAttrMaxSurface3DWidth' in found_values}}
+    #: 1 channel 32-bit floating point
+    cudaResViewFormatFloat1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat1{{endif}}
+    {{if 'cudaResViewFormatFloat2' in found_values}}
 
-    #: Maximum 3D surface width
-    cudaDevAttrMaxSurface3DWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface3DWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurface3DHeight' in found_values}}
+    #: 2 channel 32-bit floating point
+    cudaResViewFormatFloat2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat2{{endif}}
+    {{if 'cudaResViewFormatFloat4' in found_values}}
 
-    #: Maximum 3D surface height
-    cudaDevAttrMaxSurface3DHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface3DHeight{{endif}}
-    {{if 'cudaDevAttrMaxSurface3DDepth' in found_values}}
+    #: 4 channel 32-bit floating point
+    cudaResViewFormatFloat4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatFloat4{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed1' in found_values}}
 
-    #: Maximum 3D surface depth
-    cudaDevAttrMaxSurface3DDepth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface3DDepth{{endif}}
-    {{if 'cudaDevAttrMaxSurface1DLayeredWidth' in found_values}}
+    #: Block compressed 1
+    cudaResViewFormatUnsignedBlockCompressed1 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed1{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed2' in found_values}}
 
-    #: Maximum 1D layered surface width
-    cudaDevAttrMaxSurface1DLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurface1DLayeredLayers' in found_values}}
+    #: Block compressed 2
+    cudaResViewFormatUnsignedBlockCompressed2 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed2{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed3' in found_values}}
 
-    #: Maximum layers in a 1D layered surface
-    cudaDevAttrMaxSurface1DLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredLayers{{endif}}
-    {{if 'cudaDevAttrMaxSurface2DLayeredWidth' in found_values}}
+    #: Block compressed 3
+    cudaResViewFormatUnsignedBlockCompressed3 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed3{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed4' in found_values}}
 
-    #: Maximum 2D layered surface width
-    cudaDevAttrMaxSurface2DLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurface2DLayeredHeight' in found_values}}
+    #: Block compressed 4 unsigned
+    cudaResViewFormatUnsignedBlockCompressed4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed4{{endif}}
+    {{if 'cudaResViewFormatSignedBlockCompressed4' in found_values}}
 
-    #: Maximum 2D layered surface height
-    cudaDevAttrMaxSurface2DLayeredHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredHeight{{endif}}
-    {{if 'cudaDevAttrMaxSurface2DLayeredLayers' in found_values}}
+    #: Block compressed 4 signed
+    cudaResViewFormatSignedBlockCompressed4 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed4{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed5' in found_values}}
 
-    #: Maximum layers in a 2D layered surface
-    cudaDevAttrMaxSurface2DLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredLayers{{endif}}
-    {{if 'cudaDevAttrMaxSurfaceCubemapWidth' in found_values}}
+    #: Block compressed 5 unsigned
+    cudaResViewFormatUnsignedBlockCompressed5 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed5{{endif}}
+    {{if 'cudaResViewFormatSignedBlockCompressed5' in found_values}}
 
-    #: Maximum cubemap surface width
-    cudaDevAttrMaxSurfaceCubemapWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurfaceCubemapLayeredWidth' in found_values}}
+    #: Block compressed 5 signed
+    cudaResViewFormatSignedBlockCompressed5 = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed5{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed6H' in found_values}}
 
-    #: Maximum cubemap layered surface width
-    cudaDevAttrMaxSurfaceCubemapLayeredWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredWidth{{endif}}
-    {{if 'cudaDevAttrMaxSurfaceCubemapLayeredLayers' in found_values}}
+    #: Block compressed 6 unsigned half-float
+    cudaResViewFormatUnsignedBlockCompressed6H = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed6H{{endif}}
+    {{if 'cudaResViewFormatSignedBlockCompressed6H' in found_values}}
 
-    #: Maximum layers in a cubemap layered surface
-    cudaDevAttrMaxSurfaceCubemapLayeredLayers = ccudart.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredLayers{{endif}}
-    {{if 'cudaDevAttrMaxTexture1DLinearWidth' in found_values}}
+    #: Block compressed 6 signed half-float
+    cudaResViewFormatSignedBlockCompressed6H = cyruntime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed6H{{endif}}
+    {{if 'cudaResViewFormatUnsignedBlockCompressed7' in found_values}}
 
-    #: Maximum 1D linear texture width
-    cudaDevAttrMaxTexture1DLinearWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture1DLinearWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLinearWidth' in found_values}}
+    #: Block compressed 7
+    cudaResViewFormatUnsignedBlockCompressed7 = cyruntime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed7{{endif}}
+{{endif}}
+{{if 'cudaFuncAttribute' in found_types}}
 
-    #: Maximum 2D linear texture width
-    cudaDevAttrMaxTexture2DLinearWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLinearHeight' in found_values}}
+class cudaFuncAttribute(IntEnum):
+    """
+    CUDA function attributes that can be set using
+    :py:obj:`~.cudaFuncSetAttribute`
+    """
+    {{if 'cudaFuncAttributeMaxDynamicSharedMemorySize' in found_values}}
 
-    #: Maximum 2D linear texture height
-    cudaDevAttrMaxTexture2DLinearHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearHeight{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DLinearPitch' in found_values}}
+    #: Maximum dynamic shared memory size
+    cudaFuncAttributeMaxDynamicSharedMemorySize = cyruntime.cudaFuncAttribute.cudaFuncAttributeMaxDynamicSharedMemorySize{{endif}}
+    {{if 'cudaFuncAttributePreferredSharedMemoryCarveout' in found_values}}
 
-    #: Maximum 2D linear texture pitch in bytes
-    cudaDevAttrMaxTexture2DLinearPitch = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearPitch{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DMipmappedWidth' in found_values}}
+    #: Preferred shared memory-L1 cache split
+    cudaFuncAttributePreferredSharedMemoryCarveout = cyruntime.cudaFuncAttribute.cudaFuncAttributePreferredSharedMemoryCarveout{{endif}}
+    {{if 'cudaFuncAttributeClusterDimMustBeSet' in found_values}}
 
-    #: Maximum mipmapped 2D texture width
-    cudaDevAttrMaxTexture2DMipmappedWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedWidth{{endif}}
-    {{if 'cudaDevAttrMaxTexture2DMipmappedHeight' in found_values}}
+    #: Indicator to enforce valid cluster dimension specification on kernel
+    #: launch
+    cudaFuncAttributeClusterDimMustBeSet = cyruntime.cudaFuncAttribute.cudaFuncAttributeClusterDimMustBeSet{{endif}}
+    {{if 'cudaFuncAttributeRequiredClusterWidth' in found_values}}
 
-    #: Maximum mipmapped 2D texture height
-    cudaDevAttrMaxTexture2DMipmappedHeight = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedHeight{{endif}}
-    {{if 'cudaDevAttrComputeCapabilityMajor' in found_values}}
+    #: Required cluster width
+    cudaFuncAttributeRequiredClusterWidth = cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterWidth{{endif}}
+    {{if 'cudaFuncAttributeRequiredClusterHeight' in found_values}}
 
-    #: Major compute capability version number
-    cudaDevAttrComputeCapabilityMajor = ccudart.cudaDeviceAttr.cudaDevAttrComputeCapabilityMajor{{endif}}
-    {{if 'cudaDevAttrComputeCapabilityMinor' in found_values}}
+    #: Required cluster height
+    cudaFuncAttributeRequiredClusterHeight = cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterHeight{{endif}}
+    {{if 'cudaFuncAttributeRequiredClusterDepth' in found_values}}
 
-    #: Minor compute capability version number
-    cudaDevAttrComputeCapabilityMinor = ccudart.cudaDeviceAttr.cudaDevAttrComputeCapabilityMinor{{endif}}
-    {{if 'cudaDevAttrMaxTexture1DMipmappedWidth' in found_values}}
+    #: Required cluster depth
+    cudaFuncAttributeRequiredClusterDepth = cyruntime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterDepth{{endif}}
+    {{if 'cudaFuncAttributeNonPortableClusterSizeAllowed' in found_values}}
 
-    #: Maximum mipmapped 1D texture width
-    cudaDevAttrMaxTexture1DMipmappedWidth = ccudart.cudaDeviceAttr.cudaDevAttrMaxTexture1DMipmappedWidth{{endif}}
-    {{if 'cudaDevAttrStreamPrioritiesSupported' in found_values}}
+    #: Whether non-portable cluster scheduling policy is supported
+    cudaFuncAttributeNonPortableClusterSizeAllowed = cyruntime.cudaFuncAttribute.cudaFuncAttributeNonPortableClusterSizeAllowed{{endif}}
+    {{if 'cudaFuncAttributeClusterSchedulingPolicyPreference' in found_values}}
 
-    #: Device supports stream priorities
-    cudaDevAttrStreamPrioritiesSupported = ccudart.cudaDeviceAttr.cudaDevAttrStreamPrioritiesSupported{{endif}}
-    {{if 'cudaDevAttrGlobalL1CacheSupported' in found_values}}
+    #: Required cluster scheduling policy preference
+    cudaFuncAttributeClusterSchedulingPolicyPreference = cyruntime.cudaFuncAttribute.cudaFuncAttributeClusterSchedulingPolicyPreference{{endif}}
+    {{if 'cudaFuncAttributeMax' in found_values}}
+    cudaFuncAttributeMax = cyruntime.cudaFuncAttribute.cudaFuncAttributeMax{{endif}}
+{{endif}}
+{{if 'cudaFuncCache' in found_types}}
 
-    #: Device supports caching globals in L1
-    cudaDevAttrGlobalL1CacheSupported = ccudart.cudaDeviceAttr.cudaDevAttrGlobalL1CacheSupported{{endif}}
-    {{if 'cudaDevAttrLocalL1CacheSupported' in found_values}}
+class cudaFuncCache(IntEnum):
+    """
+    CUDA function cache configurations
+    """
+    {{if 'cudaFuncCachePreferNone' in found_values}}
 
-    #: Device supports caching locals in L1
-    cudaDevAttrLocalL1CacheSupported = ccudart.cudaDeviceAttr.cudaDevAttrLocalL1CacheSupported{{endif}}
-    {{if 'cudaDevAttrMaxSharedMemoryPerMultiprocessor' in found_values}}
+    #: Default function cache configuration, no preference
+    cudaFuncCachePreferNone = cyruntime.cudaFuncCache.cudaFuncCachePreferNone{{endif}}
+    {{if 'cudaFuncCachePreferShared' in found_values}}
 
-    #: Maximum shared memory available per multiprocessor in bytes
-    cudaDevAttrMaxSharedMemoryPerMultiprocessor = ccudart.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerMultiprocessor{{endif}}
-    {{if 'cudaDevAttrMaxRegistersPerMultiprocessor' in found_values}}
+    #: Prefer larger shared memory and smaller L1 cache
+    cudaFuncCachePreferShared = cyruntime.cudaFuncCache.cudaFuncCachePreferShared{{endif}}
+    {{if 'cudaFuncCachePreferL1' in found_values}}
 
-    #: Maximum number of 32-bit registers available per multiprocessor
-    cudaDevAttrMaxRegistersPerMultiprocessor = ccudart.cudaDeviceAttr.cudaDevAttrMaxRegistersPerMultiprocessor{{endif}}
-    {{if 'cudaDevAttrManagedMemory' in found_values}}
+    #: Prefer larger L1 cache and smaller shared memory
+    cudaFuncCachePreferL1 = cyruntime.cudaFuncCache.cudaFuncCachePreferL1{{endif}}
+    {{if 'cudaFuncCachePreferEqual' in found_values}}
 
-    #: Device can allocate managed memory on this system
-    cudaDevAttrManagedMemory = ccudart.cudaDeviceAttr.cudaDevAttrManagedMemory{{endif}}
-    {{if 'cudaDevAttrIsMultiGpuBoard' in found_values}}
+    #: Prefer equal size L1 cache and shared memory
+    cudaFuncCachePreferEqual = cyruntime.cudaFuncCache.cudaFuncCachePreferEqual{{endif}}
+{{endif}}
+{{if 'cudaSharedMemConfig' in found_types}}
 
-    #: Device is on a multi-GPU board
-    cudaDevAttrIsMultiGpuBoard = ccudart.cudaDeviceAttr.cudaDevAttrIsMultiGpuBoard{{endif}}
-    {{if 'cudaDevAttrMultiGpuBoardGroupID' in found_values}}
+class cudaSharedMemConfig(IntEnum):
+    """
+    CUDA shared memory configuration
+    """
+    {{if 'cudaSharedMemBankSizeDefault' in found_values}}
+    cudaSharedMemBankSizeDefault = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeDefault{{endif}}
+    {{if 'cudaSharedMemBankSizeFourByte' in found_values}}
+    cudaSharedMemBankSizeFourByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte{{endif}}
+    {{if 'cudaSharedMemBankSizeEightByte' in found_values}}
+    cudaSharedMemBankSizeEightByte = cyruntime.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte{{endif}}
+{{endif}}
+{{if 'cudaSharedCarveout' in found_types}}
 
-    #: Unique identifier for a group of devices on the same multi-GPU board
-    cudaDevAttrMultiGpuBoardGroupID = ccudart.cudaDeviceAttr.cudaDevAttrMultiGpuBoardGroupID{{endif}}
-    {{if 'cudaDevAttrHostNativeAtomicSupported' in found_values}}
+class cudaSharedCarveout(IntEnum):
+    """
+    Shared memory carveout configurations. These may be passed to
+    cudaFuncSetAttribute
+    """
+    {{if 'cudaSharedmemCarveoutDefault' in found_values}}
 
-    #: Link between the device and the host supports native atomic
-    #: operations
-    cudaDevAttrHostNativeAtomicSupported = ccudart.cudaDeviceAttr.cudaDevAttrHostNativeAtomicSupported{{endif}}
-    {{if 'cudaDevAttrSingleToDoublePrecisionPerfRatio' in found_values}}
+    #: No preference for shared memory or L1 (default)
+    cudaSharedmemCarveoutDefault = cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutDefault{{endif}}
+    {{if 'cudaSharedmemCarveoutMaxL1' in found_values}}
 
-    #: Ratio of single precision performance (in floating-point operations
-    #: per second) to double precision performance
-    cudaDevAttrSingleToDoublePrecisionPerfRatio = ccudart.cudaDeviceAttr.cudaDevAttrSingleToDoublePrecisionPerfRatio{{endif}}
-    {{if 'cudaDevAttrPageableMemoryAccess' in found_values}}
+    #: Prefer maximum available L1 cache, minimum shared memory
+    cudaSharedmemCarveoutMaxL1 = cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutMaxL1{{endif}}
+    {{if 'cudaSharedmemCarveoutMaxShared' in found_values}}
 
-    #: Device supports coherently accessing pageable memory without calling
-    #: cudaHostRegister on it
-    cudaDevAttrPageableMemoryAccess = ccudart.cudaDeviceAttr.cudaDevAttrPageableMemoryAccess{{endif}}
-    {{if 'cudaDevAttrConcurrentManagedAccess' in found_values}}
+    #: Prefer maximum available shared memory, minimum L1 cache
+    cudaSharedmemCarveoutMaxShared = cyruntime.cudaSharedCarveout.cudaSharedmemCarveoutMaxShared{{endif}}
+{{endif}}
+{{if 'cudaComputeMode' in found_types}}
 
-    #: Device can coherently access managed memory concurrently with the
-    #: CPU
-    cudaDevAttrConcurrentManagedAccess = ccudart.cudaDeviceAttr.cudaDevAttrConcurrentManagedAccess{{endif}}
-    {{if 'cudaDevAttrComputePreemptionSupported' in found_values}}
+class cudaComputeMode(IntEnum):
+    """
+    CUDA device compute modes
+    """
+    {{if 'cudaComputeModeDefault' in found_values}}
 
-    #: Device supports Compute Preemption
-    cudaDevAttrComputePreemptionSupported = ccudart.cudaDeviceAttr.cudaDevAttrComputePreemptionSupported{{endif}}
-    {{if 'cudaDevAttrCanUseHostPointerForRegisteredMem' in found_values}}
+    #: Default compute mode (Multiple threads can use
+    #: :py:obj:`~.cudaSetDevice()` with this device)
+    cudaComputeModeDefault = cyruntime.cudaComputeMode.cudaComputeModeDefault{{endif}}
+    {{if 'cudaComputeModeExclusive' in found_values}}
 
-    #: Device can access host registered memory at the same virtual address
-    #: as the CPU
-    cudaDevAttrCanUseHostPointerForRegisteredMem = ccudart.cudaDeviceAttr.cudaDevAttrCanUseHostPointerForRegisteredMem{{endif}}
-    {{if 'cudaDevAttrReserved92' in found_values}}
-    cudaDevAttrReserved92 = ccudart.cudaDeviceAttr.cudaDevAttrReserved92{{endif}}
-    {{if 'cudaDevAttrReserved93' in found_values}}
-    cudaDevAttrReserved93 = ccudart.cudaDeviceAttr.cudaDevAttrReserved93{{endif}}
-    {{if 'cudaDevAttrReserved94' in found_values}}
-    cudaDevAttrReserved94 = ccudart.cudaDeviceAttr.cudaDevAttrReserved94{{endif}}
-    {{if 'cudaDevAttrCooperativeLaunch' in found_values}}
+    #: Compute-exclusive-thread mode (Only one thread in one process will
+    #: be able to use :py:obj:`~.cudaSetDevice()` with this device)
+    cudaComputeModeExclusive = cyruntime.cudaComputeMode.cudaComputeModeExclusive{{endif}}
+    {{if 'cudaComputeModeProhibited' in found_values}}
 
-    #: Device supports launching cooperative kernels via
-    #: :py:obj:`~.cudaLaunchCooperativeKernel`
-    cudaDevAttrCooperativeLaunch = ccudart.cudaDeviceAttr.cudaDevAttrCooperativeLaunch{{endif}}
-    {{if 'cudaDevAttrCooperativeMultiDeviceLaunch' in found_values}}
+    #: Compute-prohibited mode (No threads can use
+    #: :py:obj:`~.cudaSetDevice()` with this device)
+    cudaComputeModeProhibited = cyruntime.cudaComputeMode.cudaComputeModeProhibited{{endif}}
+    {{if 'cudaComputeModeExclusiveProcess' in found_values}}
 
-    #: Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated.
-    cudaDevAttrCooperativeMultiDeviceLaunch = ccudart.cudaDeviceAttr.cudaDevAttrCooperativeMultiDeviceLaunch{{endif}}
-    {{if 'cudaDevAttrMaxSharedMemoryPerBlockOptin' in found_values}}
+    #: Compute-exclusive-process mode (Many threads in one process will be
+    #: able to use :py:obj:`~.cudaSetDevice()` with this device)
+    cudaComputeModeExclusiveProcess = cyruntime.cudaComputeMode.cudaComputeModeExclusiveProcess{{endif}}
+{{endif}}
+{{if 'cudaLimit' in found_types}}
 
-    #: The maximum optin shared memory per block. This value may vary by
-    #: chip. See :py:obj:`~.cudaFuncSetAttribute`
-    cudaDevAttrMaxSharedMemoryPerBlockOptin = ccudart.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlockOptin{{endif}}
-    {{if 'cudaDevAttrCanFlushRemoteWrites' in found_values}}
+class cudaLimit(IntEnum):
+    """
+    CUDA Limits
+    """
+    {{if 'cudaLimitStackSize' in found_values}}
 
-    #: Device supports flushing of outstanding remote writes.
-    cudaDevAttrCanFlushRemoteWrites = ccudart.cudaDeviceAttr.cudaDevAttrCanFlushRemoteWrites{{endif}}
-    {{if 'cudaDevAttrHostRegisterSupported' in found_values}}
+    #: GPU thread stack size
+    cudaLimitStackSize = cyruntime.cudaLimit.cudaLimitStackSize{{endif}}
+    {{if 'cudaLimitPrintfFifoSize' in found_values}}
 
-    #: Device supports host memory registration via
-    #: :py:obj:`~.cudaHostRegister`.
-    cudaDevAttrHostRegisterSupported = ccudart.cudaDeviceAttr.cudaDevAttrHostRegisterSupported{{endif}}
-    {{if 'cudaDevAttrPageableMemoryAccessUsesHostPageTables' in found_values}}
+    #: GPU printf FIFO size
+    cudaLimitPrintfFifoSize = cyruntime.cudaLimit.cudaLimitPrintfFifoSize{{endif}}
+    {{if 'cudaLimitMallocHeapSize' in found_values}}
 
-    #: Device accesses pageable memory via the host's page tables.
-    cudaDevAttrPageableMemoryAccessUsesHostPageTables = ccudart.cudaDeviceAttr.cudaDevAttrPageableMemoryAccessUsesHostPageTables{{endif}}
-    {{if 'cudaDevAttrDirectManagedMemAccessFromHost' in found_values}}
+    #: GPU malloc heap size
+    cudaLimitMallocHeapSize = cyruntime.cudaLimit.cudaLimitMallocHeapSize{{endif}}
+    {{if 'cudaLimitDevRuntimeSyncDepth' in found_values}}
 
-    #: Host can directly access managed memory on the device without
-    #: migration.
-    cudaDevAttrDirectManagedMemAccessFromHost = ccudart.cudaDeviceAttr.cudaDevAttrDirectManagedMemAccessFromHost{{endif}}
-    {{if 'cudaDevAttrMaxBlocksPerMultiprocessor' in found_values}}
+    #: GPU device runtime synchronize depth
+    cudaLimitDevRuntimeSyncDepth = cyruntime.cudaLimit.cudaLimitDevRuntimeSyncDepth{{endif}}
+    {{if 'cudaLimitDevRuntimePendingLaunchCount' in found_values}}
 
-    #: Maximum number of blocks per multiprocessor
-    cudaDevAttrMaxBlocksPerMultiprocessor = ccudart.cudaDeviceAttr.cudaDevAttrMaxBlocksPerMultiprocessor{{endif}}
-    {{if 'cudaDevAttrMaxPersistingL2CacheSize' in found_values}}
+    #: GPU device runtime pending launch count
+    cudaLimitDevRuntimePendingLaunchCount = cyruntime.cudaLimit.cudaLimitDevRuntimePendingLaunchCount{{endif}}
+    {{if 'cudaLimitMaxL2FetchGranularity' in found_values}}
 
-    #: Maximum L2 persisting lines capacity setting in bytes.
-    cudaDevAttrMaxPersistingL2CacheSize = ccudart.cudaDeviceAttr.cudaDevAttrMaxPersistingL2CacheSize{{endif}}
-    {{if 'cudaDevAttrMaxAccessPolicyWindowSize' in found_values}}
+    #: A value between 0 and 128 that indicates the maximum fetch
+    #: granularity of L2 (in Bytes). This is a hint
+    cudaLimitMaxL2FetchGranularity = cyruntime.cudaLimit.cudaLimitMaxL2FetchGranularity{{endif}}
+    {{if 'cudaLimitPersistingL2CacheSize' in found_values}}
 
-    #: Maximum value of :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.
-    cudaDevAttrMaxAccessPolicyWindowSize = ccudart.cudaDeviceAttr.cudaDevAttrMaxAccessPolicyWindowSize{{endif}}
-    {{if 'cudaDevAttrReservedSharedMemoryPerBlock' in found_values}}
+    #: A size in bytes for L2 persisting lines cache size
+    cudaLimitPersistingL2CacheSize = cyruntime.cudaLimit.cudaLimitPersistingL2CacheSize{{endif}}
+{{endif}}
+{{if 'cudaMemoryAdvise' in found_types}}
 
-    #: Shared memory reserved by CUDA driver per block in bytes
-    cudaDevAttrReservedSharedMemoryPerBlock = ccudart.cudaDeviceAttr.cudaDevAttrReservedSharedMemoryPerBlock{{endif}}
-    {{if 'cudaDevAttrSparseCudaArraySupported' in found_values}}
+class cudaMemoryAdvise(IntEnum):
+    """
+    CUDA Memory Advise values
+    """
+    {{if 'cudaMemAdviseSetReadMostly' in found_values}}
 
-    #: Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays
-    cudaDevAttrSparseCudaArraySupported = ccudart.cudaDeviceAttr.cudaDevAttrSparseCudaArraySupported{{endif}}
-    {{if 'cudaDevAttrHostRegisterReadOnlySupported' in found_values}}
+    #: Data will mostly be read and only occassionally be written to
+    cudaMemAdviseSetReadMostly = cyruntime.cudaMemoryAdvise.cudaMemAdviseSetReadMostly{{endif}}
+    {{if 'cudaMemAdviseUnsetReadMostly' in found_values}}
 
-    #: Device supports using the :py:obj:`~.cudaHostRegister` flag
-    #: cudaHostRegisterReadOnly to register memory that must be mapped as
-    #: read-only to the GPU
-    cudaDevAttrHostRegisterReadOnlySupported = ccudart.cudaDeviceAttr.cudaDevAttrHostRegisterReadOnlySupported{{endif}}
-    {{if 'cudaDevAttrTimelineSemaphoreInteropSupported' in found_values}}
+    #: Undo the effect of :py:obj:`~.cudaMemAdviseSetReadMostly`
+    cudaMemAdviseUnsetReadMostly = cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetReadMostly{{endif}}
+    {{if 'cudaMemAdviseSetPreferredLocation' in found_values}}
 
-    #: External timeline semaphore interop is supported on the device
-    cudaDevAttrTimelineSemaphoreInteropSupported = ccudart.cudaDeviceAttr.cudaDevAttrTimelineSemaphoreInteropSupported{{endif}}
-    {{if 'cudaDevAttrMaxTimelineSemaphoreInteropSupported' in found_values}}
+    #: Set the preferred location for the data as the specified device
+    cudaMemAdviseSetPreferredLocation = cyruntime.cudaMemoryAdvise.cudaMemAdviseSetPreferredLocation{{endif}}
+    {{if 'cudaMemAdviseUnsetPreferredLocation' in found_values}}
 
-    #: Deprecated, External timeline semaphore interop is supported on the
-    #: device
-    cudaDevAttrMaxTimelineSemaphoreInteropSupported = ccudart.cudaDeviceAttr.cudaDevAttrMaxTimelineSemaphoreInteropSupported{{endif}}
-    {{if 'cudaDevAttrMemoryPoolsSupported' in found_values}}
+    #: Clear the preferred location for the data
+    cudaMemAdviseUnsetPreferredLocation = cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetPreferredLocation{{endif}}
+    {{if 'cudaMemAdviseSetAccessedBy' in found_values}}
 
-    #: Device supports using the :py:obj:`~.cudaMallocAsync` and
-    #: :py:obj:`~.cudaMemPool` family of APIs
-    cudaDevAttrMemoryPoolsSupported = ccudart.cudaDeviceAttr.cudaDevAttrMemoryPoolsSupported{{endif}}
-    {{if 'cudaDevAttrGPUDirectRDMASupported' in found_values}}
+    #: Data will be accessed by the specified device, so prevent page
+    #: faults as much as possible
+    cudaMemAdviseSetAccessedBy = cyruntime.cudaMemoryAdvise.cudaMemAdviseSetAccessedBy{{endif}}
+    {{if 'cudaMemAdviseUnsetAccessedBy' in found_values}}
 
-    #: Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see
-    #: https://docs.nvidia.com/cuda/gpudirect-rdma for more information)
-    cudaDevAttrGPUDirectRDMASupported = ccudart.cudaDeviceAttr.cudaDevAttrGPUDirectRDMASupported{{endif}}
-    {{if 'cudaDevAttrGPUDirectRDMAFlushWritesOptions' in found_values}}
+    #: Let the Unified Memory subsystem decide on the page faulting policy
+    #: for the specified device
+    cudaMemAdviseUnsetAccessedBy = cyruntime.cudaMemoryAdvise.cudaMemAdviseUnsetAccessedBy{{endif}}
+{{endif}}
+{{if 'cudaMemRangeAttribute' in found_types}}
 
-    #: The returned attribute shall be interpreted as a bitmask, where the
-    #: individual bits are listed in the
-    #: :py:obj:`~.cudaFlushGPUDirectRDMAWritesOptions` enum
-    cudaDevAttrGPUDirectRDMAFlushWritesOptions = ccudart.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAFlushWritesOptions{{endif}}
-    {{if 'cudaDevAttrGPUDirectRDMAWritesOrdering' in found_values}}
+class cudaMemRangeAttribute(IntEnum):
+    """
+    CUDA range attributes
+    """
+    {{if 'cudaMemRangeAttributeReadMostly' in found_values}}
 
-    #: GPUDirect RDMA writes to the device do not need to be flushed for
-    #: consumers within the scope indicated by the returned attribute. See
-    #: :py:obj:`~.cudaGPUDirectRDMAWritesOrdering` for the numerical values
-    #: returned here.
-    cudaDevAttrGPUDirectRDMAWritesOrdering = ccudart.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAWritesOrdering{{endif}}
-    {{if 'cudaDevAttrMemoryPoolSupportedHandleTypes' in found_values}}
+    #: Whether the range will mostly be read and only occassionally be
+    #: written to
+    cudaMemRangeAttributeReadMostly = cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeReadMostly{{endif}}
+    {{if 'cudaMemRangeAttributePreferredLocation' in found_values}}
 
-    #: Handle types supported with mempool based IPC
-    cudaDevAttrMemoryPoolSupportedHandleTypes = ccudart.cudaDeviceAttr.cudaDevAttrMemoryPoolSupportedHandleTypes{{endif}}
-    {{if 'cudaDevAttrClusterLaunch' in found_values}}
+    #: The preferred location of the range
+    cudaMemRangeAttributePreferredLocation = cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocation{{endif}}
+    {{if 'cudaMemRangeAttributeAccessedBy' in found_values}}
 
-    #: Indicates device supports cluster launch
-    cudaDevAttrClusterLaunch = ccudart.cudaDeviceAttr.cudaDevAttrClusterLaunch{{endif}}
-    {{if 'cudaDevAttrDeferredMappingCudaArraySupported' in found_values}}
+    #: Memory range has :py:obj:`~.cudaMemAdviseSetAccessedBy` set for
+    #: specified device
+    cudaMemRangeAttributeAccessedBy = cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeAccessedBy{{endif}}
+    {{if 'cudaMemRangeAttributeLastPrefetchLocation' in found_values}}
 
-    #: Device supports deferred mapping CUDA arrays and CUDA mipmapped
-    #: arrays
-    cudaDevAttrDeferredMappingCudaArraySupported = ccudart.cudaDeviceAttr.cudaDevAttrDeferredMappingCudaArraySupported{{endif}}
-    {{if 'cudaDevAttrMax' in found_values}}
-    cudaDevAttrMax = ccudart.cudaDeviceAttr.cudaDevAttrMax{{endif}}
+    #: The last location to which the range was prefetched
+    cudaMemRangeAttributeLastPrefetchLocation = cyruntime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocation{{endif}}
 {{endif}}
-{{if 'cudaMemPoolAttr' in found_types}}
+{{if 'cudaFlushGPUDirectRDMAWritesOptions' in found_types}}
 
-class cudaMemPoolAttr(IntEnum):
+class cudaFlushGPUDirectRDMAWritesOptions(IntEnum):
     """
-    CUDA memory pool attributes
+    CUDA GPUDirect RDMA flush writes APIs supported on the device
     """
-    {{if 'cudaMemPoolReuseFollowEventDependencies' in found_values}}
-
-    #: (value type = int) Allow cuMemAllocAsync to use memory
-    #: asynchronously freed in another streams as long as a stream ordering
-    #: dependency of the allocating stream on the free action exists. Cuda
-    #: events and null stream interactions can create the required stream
-    #: ordered dependencies. (default enabled)
-    cudaMemPoolReuseFollowEventDependencies = ccudart.cudaMemPoolAttr.cudaMemPoolReuseFollowEventDependencies{{endif}}
-    {{if 'cudaMemPoolReuseAllowOpportunistic' in found_values}}
-
-    #: (value type = int) Allow reuse of already completed frees when there
-    #: is no dependency between the free and allocation. (default enabled)
-    cudaMemPoolReuseAllowOpportunistic = ccudart.cudaMemPoolAttr.cudaMemPoolReuseAllowOpportunistic{{endif}}
-    {{if 'cudaMemPoolReuseAllowInternalDependencies' in found_values}}
-
-    #: (value type = int) Allow cuMemAllocAsync to insert new stream
-    #: dependencies in order to establish the stream ordering required to
-    #: reuse a piece of memory released by cuFreeAsync (default enabled).
-    cudaMemPoolReuseAllowInternalDependencies = ccudart.cudaMemPoolAttr.cudaMemPoolReuseAllowInternalDependencies{{endif}}
-    {{if 'cudaMemPoolAttrReleaseThreshold' in found_values}}
-
-    #: (value type = cuuint64_t) Amount of reserved memory in bytes to hold
-    #: onto before trying to release memory back to the OS. When more than
-    #: the release threshold bytes of memory are held by the memory pool,
-    #: the allocator will try to release memory back to the OS on the next
-    #: call to stream, event or context synchronize. (default 0)
-    cudaMemPoolAttrReleaseThreshold = ccudart.cudaMemPoolAttr.cudaMemPoolAttrReleaseThreshold{{endif}}
-    {{if 'cudaMemPoolAttrReservedMemCurrent' in found_values}}
-
-    #: (value type = cuuint64_t) Amount of backing memory currently
-    #: allocated for the mempool.
-    cudaMemPoolAttrReservedMemCurrent = ccudart.cudaMemPoolAttr.cudaMemPoolAttrReservedMemCurrent{{endif}}
-    {{if 'cudaMemPoolAttrReservedMemHigh' in found_values}}
-
-    #: (value type = cuuint64_t) High watermark of backing memory allocated
-    #: for the mempool since the last time it was reset. High watermark can
-    #: only be reset to zero.
-    cudaMemPoolAttrReservedMemHigh = ccudart.cudaMemPoolAttr.cudaMemPoolAttrReservedMemHigh{{endif}}
-    {{if 'cudaMemPoolAttrUsedMemCurrent' in found_values}}
+    {{if 'cudaFlushGPUDirectRDMAWritesOptionHost' in found_values}}
 
-    #: (value type = cuuint64_t) Amount of memory from the pool that is
-    #: currently in use by the application.
-    cudaMemPoolAttrUsedMemCurrent = ccudart.cudaMemPoolAttr.cudaMemPoolAttrUsedMemCurrent{{endif}}
-    {{if 'cudaMemPoolAttrUsedMemHigh' in found_values}}
+    #: :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` and its CUDA Driver
+    #: API counterpart are supported on the device.
+    cudaFlushGPUDirectRDMAWritesOptionHost = cyruntime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionHost{{endif}}
+    {{if 'cudaFlushGPUDirectRDMAWritesOptionMemOps' in found_values}}
 
-    #: (value type = cuuint64_t) High watermark of the amount of memory
-    #: from the pool that was in use by the application since the last time
-    #: it was reset. High watermark can only be reset to zero.
-    cudaMemPoolAttrUsedMemHigh = ccudart.cudaMemPoolAttr.cudaMemPoolAttrUsedMemHigh{{endif}}
+    #: The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the
+    #: :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported
+    #: on the CUDA device.
+    cudaFlushGPUDirectRDMAWritesOptionMemOps = cyruntime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionMemOps{{endif}}
 {{endif}}
-{{if 'cudaMemLocationType' in found_types}}
+{{if 'cudaGPUDirectRDMAWritesOrdering' in found_types}}
 
-class cudaMemLocationType(IntEnum):
+class cudaGPUDirectRDMAWritesOrdering(IntEnum):
     """
-    Specifies the type of location
+    CUDA GPUDirect RDMA flush writes ordering features of the device
     """
-    {{if 'cudaMemLocationTypeInvalid' in found_values}}
-    cudaMemLocationTypeInvalid = ccudart.cudaMemLocationType.cudaMemLocationTypeInvalid{{endif}}
-    {{if 'cudaMemLocationTypeDevice' in found_values}}
+    {{if 'cudaGPUDirectRDMAWritesOrderingNone' in found_values}}
 
-    #: Location is a device location, thus id is a device ordinal
-    cudaMemLocationTypeDevice = ccudart.cudaMemLocationType.cudaMemLocationTypeDevice{{endif}}
+    #: The device does not natively support ordering of GPUDirect RDMA
+    #: writes. :py:obj:`~.cudaFlushGPUDirectRDMAWrites()` can be leveraged
+    #: if supported.
+    cudaGPUDirectRDMAWritesOrderingNone = cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingNone{{endif}}
+    {{if 'cudaGPUDirectRDMAWritesOrderingOwner' in found_values}}
+
+    #: Natively, the device can consistently consume GPUDirect RDMA writes,
+    #: although other CUDA devices may not.
+    cudaGPUDirectRDMAWritesOrderingOwner = cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingOwner{{endif}}
+    {{if 'cudaGPUDirectRDMAWritesOrderingAllDevices' in found_values}}
+
+    #: Any CUDA device in the system can consistently consume GPUDirect
+    #: RDMA writes to this device.
+    cudaGPUDirectRDMAWritesOrderingAllDevices = cyruntime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingAllDevices{{endif}}
 {{endif}}
-{{if 'cudaMemAccessFlags' in found_types}}
+{{if 'cudaFlushGPUDirectRDMAWritesScope' in found_types}}
 
-class cudaMemAccessFlags(IntEnum):
+class cudaFlushGPUDirectRDMAWritesScope(IntEnum):
     """
-    Specifies the memory protection flags for mapping.
+    CUDA GPUDirect RDMA flush writes scopes
     """
-    {{if 'cudaMemAccessFlagsProtNone' in found_values}}
-
-    #: Default, make the address range not accessible
-    cudaMemAccessFlagsProtNone = ccudart.cudaMemAccessFlags.cudaMemAccessFlagsProtNone{{endif}}
-    {{if 'cudaMemAccessFlagsProtRead' in found_values}}
+    {{if 'cudaFlushGPUDirectRDMAWritesToOwner' in found_values}}
 
-    #: Make the address range read accessible
-    cudaMemAccessFlagsProtRead = ccudart.cudaMemAccessFlags.cudaMemAccessFlagsProtRead{{endif}}
-    {{if 'cudaMemAccessFlagsProtReadWrite' in found_values}}
+    #: Blocks until remote writes are visible to the CUDA device context
+    #: owning the data.
+    cudaFlushGPUDirectRDMAWritesToOwner = cyruntime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToOwner{{endif}}
+    {{if 'cudaFlushGPUDirectRDMAWritesToAllDevices' in found_values}}
 
-    #: Make the address range read-write accessible
-    cudaMemAccessFlagsProtReadWrite = ccudart.cudaMemAccessFlags.cudaMemAccessFlagsProtReadWrite{{endif}}
+    #: Blocks until remote writes are visible to all CUDA device contexts.
+    cudaFlushGPUDirectRDMAWritesToAllDevices = cyruntime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToAllDevices{{endif}}
 {{endif}}
-{{if 'cudaMemAllocationType' in found_types}}
+{{if 'cudaFlushGPUDirectRDMAWritesTarget' in found_types}}
 
-class cudaMemAllocationType(IntEnum):
+class cudaFlushGPUDirectRDMAWritesTarget(IntEnum):
     """
-    Defines the allocation types available
+    CUDA GPUDirect RDMA flush writes targets
     """
-    {{if 'cudaMemAllocationTypeInvalid' in found_values}}
-    cudaMemAllocationTypeInvalid = ccudart.cudaMemAllocationType.cudaMemAllocationTypeInvalid{{endif}}
-    {{if 'cudaMemAllocationTypePinned' in found_values}}
+    {{if 'cudaFlushGPUDirectRDMAWritesTargetCurrentDevice' in found_values}}
 
-    #: This allocation type is 'pinned', i.e. cannot migrate from its
-    #: current location while the application is actively using it
-    cudaMemAllocationTypePinned = ccudart.cudaMemAllocationType.cudaMemAllocationTypePinned{{endif}}
-    {{if 'cudaMemAllocationTypeMax' in found_values}}
-    cudaMemAllocationTypeMax = ccudart.cudaMemAllocationType.cudaMemAllocationTypeMax{{endif}}
+    #: Sets the target for :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()`
+    #: to the currently active CUDA device context.
+    cudaFlushGPUDirectRDMAWritesTargetCurrentDevice = cyruntime.cudaFlushGPUDirectRDMAWritesTarget.cudaFlushGPUDirectRDMAWritesTargetCurrentDevice{{endif}}
 {{endif}}
-{{if 'cudaMemAllocationHandleType' in found_types}}
+{{if 'cudaDeviceAttr' in found_types}}
 
-class cudaMemAllocationHandleType(IntEnum):
+class cudaDeviceAttr(IntEnum):
     """
-    Flags for specifying particular handle types
+    CUDA device attributes
     """
-    {{if 'cudaMemHandleTypeNone' in found_values}}
+    {{if 'cudaDevAttrMaxThreadsPerBlock' in found_values}}
 
-    #: Does not allow any export mechanism. >
-    cudaMemHandleTypeNone = ccudart.cudaMemAllocationHandleType.cudaMemHandleTypeNone{{endif}}
-    {{if 'cudaMemHandleTypePosixFileDescriptor' in found_values}}
+    #: Maximum number of threads per block
+    cudaDevAttrMaxThreadsPerBlock = cyruntime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerBlock{{endif}}
+    {{if 'cudaDevAttrMaxBlockDimX' in found_values}}
 
-    #: Allows a file descriptor to be used for exporting. Permitted only on
-    #: POSIX systems. (int)
-    cudaMemHandleTypePosixFileDescriptor = ccudart.cudaMemAllocationHandleType.cudaMemHandleTypePosixFileDescriptor{{endif}}
-    {{if 'cudaMemHandleTypeWin32' in found_values}}
+    #: Maximum block dimension X
+    cudaDevAttrMaxBlockDimX = cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimX{{endif}}
+    {{if 'cudaDevAttrMaxBlockDimY' in found_values}}
 
-    #: Allows a Win32 NT handle to be used for exporting. (HANDLE)
-    cudaMemHandleTypeWin32 = ccudart.cudaMemAllocationHandleType.cudaMemHandleTypeWin32{{endif}}
-    {{if 'cudaMemHandleTypeWin32Kmt' in found_values}}
+    #: Maximum block dimension Y
+    cudaDevAttrMaxBlockDimY = cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimY{{endif}}
+    {{if 'cudaDevAttrMaxBlockDimZ' in found_values}}
 
-    #: Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)
-    cudaMemHandleTypeWin32Kmt = ccudart.cudaMemAllocationHandleType.cudaMemHandleTypeWin32Kmt{{endif}}
-{{endif}}
-{{if 'cudaGraphMemAttributeType' in found_types}}
+    #: Maximum block dimension Z
+    cudaDevAttrMaxBlockDimZ = cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlockDimZ{{endif}}
+    {{if 'cudaDevAttrMaxGridDimX' in found_values}}
 
-class cudaGraphMemAttributeType(IntEnum):
-    """
-    Graph memory attributes
-    """
-    {{if 'cudaGraphMemAttrUsedMemCurrent' in found_values}}
+    #: Maximum grid dimension X
+    cudaDevAttrMaxGridDimX = cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimX{{endif}}
+    {{if 'cudaDevAttrMaxGridDimY' in found_values}}
 
-    #: (value type = cuuint64_t) Amount of memory, in bytes, currently
-    #: associated with graphs.
-    cudaGraphMemAttrUsedMemCurrent = ccudart.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemCurrent{{endif}}
-    {{if 'cudaGraphMemAttrUsedMemHigh' in found_values}}
+    #: Maximum grid dimension Y
+    cudaDevAttrMaxGridDimY = cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimY{{endif}}
+    {{if 'cudaDevAttrMaxGridDimZ' in found_values}}
 
-    #: (value type = cuuint64_t) High watermark of memory, in bytes,
-    #: associated with graphs since the last time it was reset. High
-    #: watermark can only be reset to zero.
-    cudaGraphMemAttrUsedMemHigh = ccudart.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemHigh{{endif}}
-    {{if 'cudaGraphMemAttrReservedMemCurrent' in found_values}}
+    #: Maximum grid dimension Z
+    cudaDevAttrMaxGridDimZ = cyruntime.cudaDeviceAttr.cudaDevAttrMaxGridDimZ{{endif}}
+    {{if 'cudaDevAttrMaxSharedMemoryPerBlock' in found_values}}
 
-    #: (value type = cuuint64_t) Amount of memory, in bytes, currently
-    #: allocated for use by the CUDA graphs asynchronous allocator.
-    cudaGraphMemAttrReservedMemCurrent = ccudart.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemCurrent{{endif}}
-    {{if 'cudaGraphMemAttrReservedMemHigh' in found_values}}
+    #: Maximum shared memory available per block in bytes
+    cudaDevAttrMaxSharedMemoryPerBlock = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlock{{endif}}
+    {{if 'cudaDevAttrTotalConstantMemory' in found_values}}
 
-    #: (value type = cuuint64_t) High watermark of memory, in bytes,
-    #: currently allocated for use by the CUDA graphs asynchronous
-    #: allocator.
-    cudaGraphMemAttrReservedMemHigh = ccudart.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemHigh{{endif}}
-{{endif}}
-{{if 'cudaDeviceP2PAttr' in found_types}}
+    #: Memory available on device for constant variables in a CUDA C kernel
+    #: in bytes
+    cudaDevAttrTotalConstantMemory = cyruntime.cudaDeviceAttr.cudaDevAttrTotalConstantMemory{{endif}}
+    {{if 'cudaDevAttrWarpSize' in found_values}}
 
-class cudaDeviceP2PAttr(IntEnum):
-    """
-    CUDA device P2P attributes
-    """
-    {{if 'cudaDevP2PAttrPerformanceRank' in found_values}}
+    #: Warp size in threads
+    cudaDevAttrWarpSize = cyruntime.cudaDeviceAttr.cudaDevAttrWarpSize{{endif}}
+    {{if 'cudaDevAttrMaxPitch' in found_values}}
 
-    #: A relative value indicating the performance of the link between two
-    #: devices
-    cudaDevP2PAttrPerformanceRank = ccudart.cudaDeviceP2PAttr.cudaDevP2PAttrPerformanceRank{{endif}}
-    {{if 'cudaDevP2PAttrAccessSupported' in found_values}}
+    #: Maximum pitch in bytes allowed by memory copies
+    cudaDevAttrMaxPitch = cyruntime.cudaDeviceAttr.cudaDevAttrMaxPitch{{endif}}
+    {{if 'cudaDevAttrMaxRegistersPerBlock' in found_values}}
 
-    #: Peer access is enabled
-    cudaDevP2PAttrAccessSupported = ccudart.cudaDeviceP2PAttr.cudaDevP2PAttrAccessSupported{{endif}}
-    {{if 'cudaDevP2PAttrNativeAtomicSupported' in found_values}}
+    #: Maximum number of 32-bit registers available per block
+    cudaDevAttrMaxRegistersPerBlock = cyruntime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerBlock{{endif}}
+    {{if 'cudaDevAttrClockRate' in found_values}}
 
-    #: Native atomic operation over the link supported
-    cudaDevP2PAttrNativeAtomicSupported = ccudart.cudaDeviceP2PAttr.cudaDevP2PAttrNativeAtomicSupported{{endif}}
-    {{if 'cudaDevP2PAttrCudaArrayAccessSupported' in found_values}}
+    #: Peak clock frequency in kilohertz
+    cudaDevAttrClockRate = cyruntime.cudaDeviceAttr.cudaDevAttrClockRate{{endif}}
+    {{if 'cudaDevAttrTextureAlignment' in found_values}}
 
-    #: Accessing CUDA arrays over the link supported
-    cudaDevP2PAttrCudaArrayAccessSupported = ccudart.cudaDeviceP2PAttr.cudaDevP2PAttrCudaArrayAccessSupported{{endif}}
-{{endif}}
-{{if 'cudaExternalMemoryHandleType' in found_types}}
+    #: Alignment requirement for textures
+    cudaDevAttrTextureAlignment = cyruntime.cudaDeviceAttr.cudaDevAttrTextureAlignment{{endif}}
+    {{if 'cudaDevAttrGpuOverlap' in found_values}}
 
-class cudaExternalMemoryHandleType(IntEnum):
-    """
-    External memory handle types
-    """
-    {{if 'cudaExternalMemoryHandleTypeOpaqueFd' in found_values}}
+    #: Device can possibly copy memory and execute a kernel concurrently
+    cudaDevAttrGpuOverlap = cyruntime.cudaDeviceAttr.cudaDevAttrGpuOverlap{{endif}}
+    {{if 'cudaDevAttrMultiProcessorCount' in found_values}}
 
-    #: Handle is an opaque file descriptor
-    cudaExternalMemoryHandleTypeOpaqueFd = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeOpaqueWin32' in found_values}}
+    #: Number of multiprocessors on device
+    cudaDevAttrMultiProcessorCount = cyruntime.cudaDeviceAttr.cudaDevAttrMultiProcessorCount{{endif}}
+    {{if 'cudaDevAttrKernelExecTimeout' in found_values}}
 
-    #: Handle is an opaque shared NT handle
-    cudaExternalMemoryHandleTypeOpaqueWin32 = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeOpaqueWin32Kmt' in found_values}}
+    #: Specifies whether there is a run time limit on kernels
+    cudaDevAttrKernelExecTimeout = cyruntime.cudaDeviceAttr.cudaDevAttrKernelExecTimeout{{endif}}
+    {{if 'cudaDevAttrIntegrated' in found_values}}
 
-    #: Handle is an opaque, globally shared handle
-    cudaExternalMemoryHandleTypeOpaqueWin32Kmt = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeD3D12Heap' in found_values}}
+    #: Device is integrated with host memory
+    cudaDevAttrIntegrated = cyruntime.cudaDeviceAttr.cudaDevAttrIntegrated{{endif}}
+    {{if 'cudaDevAttrCanMapHostMemory' in found_values}}
 
-    #: Handle is a D3D12 heap object
-    cudaExternalMemoryHandleTypeD3D12Heap = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeD3D12Resource' in found_values}}
+    #: Device can map host memory into CUDA address space
+    cudaDevAttrCanMapHostMemory = cyruntime.cudaDeviceAttr.cudaDevAttrCanMapHostMemory{{endif}}
+    {{if 'cudaDevAttrComputeMode' in found_values}}
 
-    #: Handle is a D3D12 committed resource
-    cudaExternalMemoryHandleTypeD3D12Resource = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeD3D11Resource' in found_values}}
+    #: Compute mode (See :py:obj:`~.cudaComputeMode` for details)
+    cudaDevAttrComputeMode = cyruntime.cudaDeviceAttr.cudaDevAttrComputeMode{{endif}}
+    {{if 'cudaDevAttrMaxTexture1DWidth' in found_values}}
 
-    #: Handle is a shared NT handle to a D3D11 resource
-    cudaExternalMemoryHandleTypeD3D11Resource = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeD3D11ResourceKmt' in found_values}}
+    #: Maximum 1D texture width
+    cudaDevAttrMaxTexture1DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DWidth' in found_values}}
 
-    #: Handle is a globally shared handle to a D3D11 resource
-    cudaExternalMemoryHandleTypeD3D11ResourceKmt = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt{{endif}}
-    {{if 'cudaExternalMemoryHandleTypeNvSciBuf' in found_values}}
+    #: Maximum 2D texture width
+    cudaDevAttrMaxTexture2DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DHeight' in found_values}}
 
-    #: Handle is an NvSciBuf object
-    cudaExternalMemoryHandleTypeNvSciBuf = ccudart.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf{{endif}}
-{{endif}}
-{{if 'cudaExternalSemaphoreHandleType' in found_types}}
+    #: Maximum 2D texture height
+    cudaDevAttrMaxTexture2DHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DHeight{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DWidth' in found_values}}
 
-class cudaExternalSemaphoreHandleType(IntEnum):
-    """
-    External semaphore handle types
-    """
-    {{if 'cudaExternalSemaphoreHandleTypeOpaqueFd' in found_values}}
+    #: Maximum 3D texture width
+    cudaDevAttrMaxTexture3DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DHeight' in found_values}}
 
-    #: Handle is an opaque file descriptor
-    cudaExternalSemaphoreHandleTypeOpaqueFd = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32' in found_values}}
+    #: Maximum 3D texture height
+    cudaDevAttrMaxTexture3DHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeight{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DDepth' in found_values}}
 
-    #: Handle is an opaque shared NT handle
-    cudaExternalSemaphoreHandleTypeOpaqueWin32 = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt' in found_values}}
+    #: Maximum 3D texture depth
+    cudaDevAttrMaxTexture3DDepth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLayeredWidth' in found_values}}
 
-    #: Handle is an opaque, globally shared handle
-    cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeD3D12Fence' in found_values}}
+    #: Maximum 2D layered texture width
+    cudaDevAttrMaxTexture2DLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLayeredHeight' in found_values}}
 
-    #: Handle is a shared NT handle referencing a D3D12 fence object
-    cudaExternalSemaphoreHandleTypeD3D12Fence = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeD3D11Fence' in found_values}}
+    #: Maximum 2D layered texture height
+    cudaDevAttrMaxTexture2DLayeredHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredHeight{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLayeredLayers' in found_values}}
 
-    #: Handle is a shared NT handle referencing a D3D11 fence object
-    cudaExternalSemaphoreHandleTypeD3D11Fence = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeNvSciSync' in found_values}}
+    #: Maximum layers in a 2D layered texture
+    cudaDevAttrMaxTexture2DLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredLayers{{endif}}
+    {{if 'cudaDevAttrSurfaceAlignment' in found_values}}
 
-    #: Opaque handle to NvSciSync Object
-    cudaExternalSemaphoreHandleTypeNvSciSync = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeKeyedMutex' in found_values}}
+    #: Alignment requirement for surfaces
+    cudaDevAttrSurfaceAlignment = cyruntime.cudaDeviceAttr.cudaDevAttrSurfaceAlignment{{endif}}
+    {{if 'cudaDevAttrConcurrentKernels' in found_values}}
 
-    #: Handle is a shared NT handle referencing a D3D11 keyed mutex object
-    cudaExternalSemaphoreHandleTypeKeyedMutex = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeKeyedMutexKmt' in found_values}}
+    #: Device can possibly execute multiple kernels concurrently
+    cudaDevAttrConcurrentKernels = cyruntime.cudaDeviceAttr.cudaDevAttrConcurrentKernels{{endif}}
+    {{if 'cudaDevAttrEccEnabled' in found_values}}
 
-    #: Handle is a shared KMT handle referencing a D3D11 keyed mutex object
-    cudaExternalSemaphoreHandleTypeKeyedMutexKmt = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd' in found_values}}
+    #: Device has ECC support enabled
+    cudaDevAttrEccEnabled = cyruntime.cudaDeviceAttr.cudaDevAttrEccEnabled{{endif}}
+    {{if 'cudaDevAttrPciBusId' in found_values}}
 
-    #: Handle is an opaque handle file descriptor referencing a timeline
-    #: semaphore
-    cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd{{endif}}
-    {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32' in found_values}}
+    #: PCI bus ID of the device
+    cudaDevAttrPciBusId = cyruntime.cudaDeviceAttr.cudaDevAttrPciBusId{{endif}}
+    {{if 'cudaDevAttrPciDeviceId' in found_values}}
 
-    #: Handle is an opaque handle file descriptor referencing a timeline
-    #: semaphore
-    cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = ccudart.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32{{endif}}
-{{endif}}
-{{if 'cudaCGScope' in found_types}}
+    #: PCI device ID of the device
+    cudaDevAttrPciDeviceId = cyruntime.cudaDeviceAttr.cudaDevAttrPciDeviceId{{endif}}
+    {{if 'cudaDevAttrTccDriver' in found_values}}
 
-class cudaCGScope(IntEnum):
-    """
-    CUDA cooperative group scope
-    """
-    {{if 'cudaCGScopeInvalid' in found_values}}
+    #: Device is using TCC driver model
+    cudaDevAttrTccDriver = cyruntime.cudaDeviceAttr.cudaDevAttrTccDriver{{endif}}
+    {{if 'cudaDevAttrMemoryClockRate' in found_values}}
 
-    #: Invalid cooperative group scope
-    cudaCGScopeInvalid = ccudart.cudaCGScope.cudaCGScopeInvalid{{endif}}
-    {{if 'cudaCGScopeGrid' in found_values}}
+    #: Peak memory clock frequency in kilohertz
+    cudaDevAttrMemoryClockRate = cyruntime.cudaDeviceAttr.cudaDevAttrMemoryClockRate{{endif}}
+    {{if 'cudaDevAttrGlobalMemoryBusWidth' in found_values}}
 
-    #: Scope represented by a grid_group
-    cudaCGScopeGrid = ccudart.cudaCGScope.cudaCGScopeGrid{{endif}}
-    {{if 'cudaCGScopeMultiGrid' in found_values}}
+    #: Global memory bus width in bits
+    cudaDevAttrGlobalMemoryBusWidth = cyruntime.cudaDeviceAttr.cudaDevAttrGlobalMemoryBusWidth{{endif}}
+    {{if 'cudaDevAttrL2CacheSize' in found_values}}
 
-    #: Scope represented by a multi_grid_group
-    cudaCGScopeMultiGrid = ccudart.cudaCGScope.cudaCGScopeMultiGrid{{endif}}
-{{endif}}
-{{if 'cudaGraphNodeType' in found_types}}
+    #: Size of L2 cache in bytes
+    cudaDevAttrL2CacheSize = cyruntime.cudaDeviceAttr.cudaDevAttrL2CacheSize{{endif}}
+    {{if 'cudaDevAttrMaxThreadsPerMultiProcessor' in found_values}}
 
-class cudaGraphNodeType(IntEnum):
-    """
-    CUDA Graph node types
-    """
-    {{if 'cudaGraphNodeTypeKernel' in found_values}}
+    #: Maximum resident threads per multiprocessor
+    cudaDevAttrMaxThreadsPerMultiProcessor = cyruntime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerMultiProcessor{{endif}}
+    {{if 'cudaDevAttrAsyncEngineCount' in found_values}}
 
-    #: GPU kernel node
-    cudaGraphNodeTypeKernel = ccudart.cudaGraphNodeType.cudaGraphNodeTypeKernel{{endif}}
-    {{if 'cudaGraphNodeTypeMemcpy' in found_values}}
+    #: Number of asynchronous engines
+    cudaDevAttrAsyncEngineCount = cyruntime.cudaDeviceAttr.cudaDevAttrAsyncEngineCount{{endif}}
+    {{if 'cudaDevAttrUnifiedAddressing' in found_values}}
 
-    #: Memcpy node
-    cudaGraphNodeTypeMemcpy = ccudart.cudaGraphNodeType.cudaGraphNodeTypeMemcpy{{endif}}
-    {{if 'cudaGraphNodeTypeMemset' in found_values}}
+    #: Device shares a unified address space with the host
+    cudaDevAttrUnifiedAddressing = cyruntime.cudaDeviceAttr.cudaDevAttrUnifiedAddressing{{endif}}
+    {{if 'cudaDevAttrMaxTexture1DLayeredWidth' in found_values}}
 
-    #: Memset node
-    cudaGraphNodeTypeMemset = ccudart.cudaGraphNodeType.cudaGraphNodeTypeMemset{{endif}}
-    {{if 'cudaGraphNodeTypeHost' in found_values}}
+    #: Maximum 1D layered texture width
+    cudaDevAttrMaxTexture1DLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture1DLayeredLayers' in found_values}}
 
-    #: Host (executable) node
-    cudaGraphNodeTypeHost = ccudart.cudaGraphNodeType.cudaGraphNodeTypeHost{{endif}}
-    {{if 'cudaGraphNodeTypeGraph' in found_values}}
+    #: Maximum layers in a 1D layered texture
+    cudaDevAttrMaxTexture1DLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredLayers{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DGatherWidth' in found_values}}
 
-    #: Node which executes an embedded graph
-    cudaGraphNodeTypeGraph = ccudart.cudaGraphNodeType.cudaGraphNodeTypeGraph{{endif}}
-    {{if 'cudaGraphNodeTypeEmpty' in found_values}}
+    #: Maximum 2D texture width if cudaArrayTextureGather is set
+    cudaDevAttrMaxTexture2DGatherWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DGatherHeight' in found_values}}
 
-    #: Empty (no-op) node
-    cudaGraphNodeTypeEmpty = ccudart.cudaGraphNodeType.cudaGraphNodeTypeEmpty{{endif}}
-    {{if 'cudaGraphNodeTypeWaitEvent' in found_values}}
+    #: Maximum 2D texture height if cudaArrayTextureGather is set
+    cudaDevAttrMaxTexture2DGatherHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherHeight{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DWidthAlt' in found_values}}
 
-    #: External event wait node
-    cudaGraphNodeTypeWaitEvent = ccudart.cudaGraphNodeType.cudaGraphNodeTypeWaitEvent{{endif}}
-    {{if 'cudaGraphNodeTypeEventRecord' in found_values}}
+    #: Alternate maximum 3D texture width
+    cudaDevAttrMaxTexture3DWidthAlt = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidthAlt{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DHeightAlt' in found_values}}
 
-    #: External event record node
-    cudaGraphNodeTypeEventRecord = ccudart.cudaGraphNodeType.cudaGraphNodeTypeEventRecord{{endif}}
-    {{if 'cudaGraphNodeTypeExtSemaphoreSignal' in found_values}}
+    #: Alternate maximum 3D texture height
+    cudaDevAttrMaxTexture3DHeightAlt = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeightAlt{{endif}}
+    {{if 'cudaDevAttrMaxTexture3DDepthAlt' in found_values}}
 
-    #: External semaphore signal node
-    cudaGraphNodeTypeExtSemaphoreSignal = ccudart.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreSignal{{endif}}
-    {{if 'cudaGraphNodeTypeExtSemaphoreWait' in found_values}}
+    #: Alternate maximum 3D texture depth
+    cudaDevAttrMaxTexture3DDepthAlt = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepthAlt{{endif}}
+    {{if 'cudaDevAttrPciDomainId' in found_values}}
 
-    #: External semaphore wait node
-    cudaGraphNodeTypeExtSemaphoreWait = ccudart.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreWait{{endif}}
-    {{if 'cudaGraphNodeTypeMemAlloc' in found_values}}
+    #: PCI domain ID of the device
+    cudaDevAttrPciDomainId = cyruntime.cudaDeviceAttr.cudaDevAttrPciDomainId{{endif}}
+    {{if 'cudaDevAttrTexturePitchAlignment' in found_values}}
 
-    #: Memory allocation node
-    cudaGraphNodeTypeMemAlloc = ccudart.cudaGraphNodeType.cudaGraphNodeTypeMemAlloc{{endif}}
-    {{if 'cudaGraphNodeTypeMemFree' in found_values}}
+    #: Pitch alignment requirement for textures
+    cudaDevAttrTexturePitchAlignment = cyruntime.cudaDeviceAttr.cudaDevAttrTexturePitchAlignment{{endif}}
+    {{if 'cudaDevAttrMaxTextureCubemapWidth' in found_values}}
 
-    #: Memory free node
-    cudaGraphNodeTypeMemFree = ccudart.cudaGraphNodeType.cudaGraphNodeTypeMemFree{{endif}}
-    {{if 'cudaGraphNodeTypeCount' in found_values}}
-    cudaGraphNodeTypeCount = ccudart.cudaGraphNodeType.cudaGraphNodeTypeCount{{endif}}
-{{endif}}
-{{if 'cudaGraphExecUpdateResult' in found_types}}
+    #: Maximum cubemap texture width/height
+    cudaDevAttrMaxTextureCubemapWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapWidth{{endif}}
+    {{if 'cudaDevAttrMaxTextureCubemapLayeredWidth' in found_values}}
 
-class cudaGraphExecUpdateResult(IntEnum):
-    """
-    CUDA Graph Update error types
-    """
-    {{if 'cudaGraphExecUpdateSuccess' in found_values}}
+    #: Maximum cubemap layered texture width/height
+    cudaDevAttrMaxTextureCubemapLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxTextureCubemapLayeredLayers' in found_values}}
 
-    #: The update succeeded
-    cudaGraphExecUpdateSuccess = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateSuccess{{endif}}
-    {{if 'cudaGraphExecUpdateError' in found_values}}
+    #: Maximum layers in a cubemap layered texture
+    cudaDevAttrMaxTextureCubemapLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredLayers{{endif}}
+    {{if 'cudaDevAttrMaxSurface1DWidth' in found_values}}
 
-    #: The update failed for an unexpected reason which is described in the
-    #: return value of the function
-    cudaGraphExecUpdateError = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateError{{endif}}
-    {{if 'cudaGraphExecUpdateErrorTopologyChanged' in found_values}}
+    #: Maximum 1D surface width
+    cudaDevAttrMaxSurface1DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurface2DWidth' in found_values}}
 
-    #: The update failed because the topology changed
-    cudaGraphExecUpdateErrorTopologyChanged = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorTopologyChanged{{endif}}
-    {{if 'cudaGraphExecUpdateErrorNodeTypeChanged' in found_values}}
+    #: Maximum 2D surface width
+    cudaDevAttrMaxSurface2DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurface2DHeight' in found_values}}
 
-    #: The update failed because a node type changed
-    cudaGraphExecUpdateErrorNodeTypeChanged = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNodeTypeChanged{{endif}}
-    {{if 'cudaGraphExecUpdateErrorFunctionChanged' in found_values}}
+    #: Maximum 2D surface height
+    cudaDevAttrMaxSurface2DHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DHeight{{endif}}
+    {{if 'cudaDevAttrMaxSurface3DWidth' in found_values}}
 
-    #: The update failed because the function of a kernel node changed
-    #: (CUDA driver < 11.2)
-    cudaGraphExecUpdateErrorFunctionChanged = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorFunctionChanged{{endif}}
-    {{if 'cudaGraphExecUpdateErrorParametersChanged' in found_values}}
+    #: Maximum 3D surface width
+    cudaDevAttrMaxSurface3DWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurface3DHeight' in found_values}}
 
-    #: The update failed because the parameters changed in a way that is
-    #: not supported
-    cudaGraphExecUpdateErrorParametersChanged = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorParametersChanged{{endif}}
-    {{if 'cudaGraphExecUpdateErrorNotSupported' in found_values}}
+    #: Maximum 3D surface height
+    cudaDevAttrMaxSurface3DHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DHeight{{endif}}
+    {{if 'cudaDevAttrMaxSurface3DDepth' in found_values}}
 
-    #: The update failed because something about the node is not supported
-    cudaGraphExecUpdateErrorNotSupported = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNotSupported{{endif}}
-    {{if 'cudaGraphExecUpdateErrorUnsupportedFunctionChange' in found_values}}
+    #: Maximum 3D surface depth
+    cudaDevAttrMaxSurface3DDepth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface3DDepth{{endif}}
+    {{if 'cudaDevAttrMaxSurface1DLayeredWidth' in found_values}}
 
-    #: The update failed because the function of a kernel node changed in
-    #: an unsupported way
-    cudaGraphExecUpdateErrorUnsupportedFunctionChange = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorUnsupportedFunctionChange{{endif}}
-    {{if 'cudaGraphExecUpdateErrorAttributesChanged' in found_values}}
+    #: Maximum 1D layered surface width
+    cudaDevAttrMaxSurface1DLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurface1DLayeredLayers' in found_values}}
 
-    #: The update failed because the node attributes changed in a way that
-    #: is not supported
-    cudaGraphExecUpdateErrorAttributesChanged = ccudart.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorAttributesChanged{{endif}}
-{{endif}}
-{{if 'cudaGetDriverEntryPointFlags' in found_types}}
+    #: Maximum layers in a 1D layered surface
+    cudaDevAttrMaxSurface1DLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredLayers{{endif}}
+    {{if 'cudaDevAttrMaxSurface2DLayeredWidth' in found_values}}
 
-class cudaGetDriverEntryPointFlags(IntEnum):
-    """
-    Flags to specify search options to be used with
-    :py:obj:`~.cudaGetDriverEntryPoint` For more details see
-    :py:obj:`~.cuGetProcAddress`
-    """
-    {{if 'cudaEnableDefault' in found_values}}
+    #: Maximum 2D layered surface width
+    cudaDevAttrMaxSurface2DLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurface2DLayeredHeight' in found_values}}
 
-    #: Default search mode for driver symbols.
-    cudaEnableDefault = ccudart.cudaGetDriverEntryPointFlags.cudaEnableDefault{{endif}}
-    {{if 'cudaEnableLegacyStream' in found_values}}
+    #: Maximum 2D layered surface height
+    cudaDevAttrMaxSurface2DLayeredHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredHeight{{endif}}
+    {{if 'cudaDevAttrMaxSurface2DLayeredLayers' in found_values}}
 
-    #: Search for legacy versions of driver symbols.
-    cudaEnableLegacyStream = ccudart.cudaGetDriverEntryPointFlags.cudaEnableLegacyStream{{endif}}
-    {{if 'cudaEnablePerThreadDefaultStream' in found_values}}
+    #: Maximum layers in a 2D layered surface
+    cudaDevAttrMaxSurface2DLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredLayers{{endif}}
+    {{if 'cudaDevAttrMaxSurfaceCubemapWidth' in found_values}}
 
-    #: Search for per-thread versions of driver symbols.
-    cudaEnablePerThreadDefaultStream = ccudart.cudaGetDriverEntryPointFlags.cudaEnablePerThreadDefaultStream{{endif}}
-{{endif}}
-{{if 'cudaGraphDebugDotFlags' in found_types}}
+    #: Maximum cubemap surface width
+    cudaDevAttrMaxSurfaceCubemapWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurfaceCubemapLayeredWidth' in found_values}}
 
-class cudaGraphDebugDotFlags(IntEnum):
-    """
-    CUDA Graph debug write options
-    """
-    {{if 'cudaGraphDebugDotFlagsVerbose' in found_values}}
+    #: Maximum cubemap layered surface width
+    cudaDevAttrMaxSurfaceCubemapLayeredWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredWidth{{endif}}
+    {{if 'cudaDevAttrMaxSurfaceCubemapLayeredLayers' in found_values}}
 
-    #: Output all debug data as if every debug flag is enabled
-    cudaGraphDebugDotFlagsVerbose = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsVerbose{{endif}}
-    {{if 'cudaGraphDebugDotFlagsKernelNodeParams' in found_values}}
+    #: Maximum layers in a cubemap layered surface
+    cudaDevAttrMaxSurfaceCubemapLayeredLayers = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredLayers{{endif}}
+    {{if 'cudaDevAttrMaxTexture1DLinearWidth' in found_values}}
 
-    #: Adds :py:obj:`~.cudaKernelNodeParams` to output
-    cudaGraphDebugDotFlagsKernelNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsMemcpyNodeParams' in found_values}}
+    #: Maximum 1D linear texture width
+    cudaDevAttrMaxTexture1DLinearWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLinearWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLinearWidth' in found_values}}
 
-    #: Adds :py:obj:`~.cudaMemcpy3DParms` to output
-    cudaGraphDebugDotFlagsMemcpyNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemcpyNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsMemsetNodeParams' in found_values}}
+    #: Maximum 2D linear texture width
+    cudaDevAttrMaxTexture2DLinearWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLinearHeight' in found_values}}
 
-    #: Adds :py:obj:`~.cudaMemsetParams` to output
-    cudaGraphDebugDotFlagsMemsetNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemsetNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsHostNodeParams' in found_values}}
+    #: Maximum 2D linear texture height
+    cudaDevAttrMaxTexture2DLinearHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearHeight{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DLinearPitch' in found_values}}
 
-    #: Adds :py:obj:`~.cudaHostNodeParams` to output
-    cudaGraphDebugDotFlagsHostNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHostNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsEventNodeParams' in found_values}}
+    #: Maximum 2D linear texture pitch in bytes
+    cudaDevAttrMaxTexture2DLinearPitch = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearPitch{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DMipmappedWidth' in found_values}}
 
-    #: Adds cudaEvent_t handle from record and wait nodes to output
-    cudaGraphDebugDotFlagsEventNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsEventNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsExtSemasSignalNodeParams' in found_values}}
+    #: Maximum mipmapped 2D texture width
+    cudaDevAttrMaxTexture2DMipmappedWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedWidth{{endif}}
+    {{if 'cudaDevAttrMaxTexture2DMipmappedHeight' in found_values}}
 
-    #: Adds :py:obj:`~.cudaExternalSemaphoreSignalNodeParams` values to
-    #: output
-    cudaGraphDebugDotFlagsExtSemasSignalNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasSignalNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsExtSemasWaitNodeParams' in found_values}}
+    #: Maximum mipmapped 2D texture height
+    cudaDevAttrMaxTexture2DMipmappedHeight = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedHeight{{endif}}
+    {{if 'cudaDevAttrComputeCapabilityMajor' in found_values}}
 
-    #: Adds :py:obj:`~.cudaExternalSemaphoreWaitNodeParams` to output
-    cudaGraphDebugDotFlagsExtSemasWaitNodeParams = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasWaitNodeParams{{endif}}
-    {{if 'cudaGraphDebugDotFlagsKernelNodeAttributes' in found_values}}
+    #: Major compute capability version number
+    cudaDevAttrComputeCapabilityMajor = cyruntime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMajor{{endif}}
+    {{if 'cudaDevAttrComputeCapabilityMinor' in found_values}}
 
-    #: Adds cudaKernelNodeAttrID values to output
-    cudaGraphDebugDotFlagsKernelNodeAttributes = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeAttributes{{endif}}
-    {{if 'cudaGraphDebugDotFlagsHandles' in found_values}}
+    #: Minor compute capability version number
+    cudaDevAttrComputeCapabilityMinor = cyruntime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMinor{{endif}}
+    {{if 'cudaDevAttrMaxTexture1DMipmappedWidth' in found_values}}
 
-    #: Adds node handles and every kernel function handle to output
-    cudaGraphDebugDotFlagsHandles = ccudart.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHandles{{endif}}
-{{endif}}
-{{if 'cudaGraphInstantiateFlags' in found_types}}
+    #: Maximum mipmapped 1D texture width
+    cudaDevAttrMaxTexture1DMipmappedWidth = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTexture1DMipmappedWidth{{endif}}
+    {{if 'cudaDevAttrStreamPrioritiesSupported' in found_values}}
 
-class cudaGraphInstantiateFlags(IntEnum):
-    """
-    Flags for instantiating a graph
-    """
-    {{if 'cudaGraphInstantiateFlagAutoFreeOnLaunch' in found_values}}
+    #: Device supports stream priorities
+    cudaDevAttrStreamPrioritiesSupported = cyruntime.cudaDeviceAttr.cudaDevAttrStreamPrioritiesSupported{{endif}}
+    {{if 'cudaDevAttrGlobalL1CacheSupported' in found_values}}
 
-    #: Automatically free memory allocated in a graph before relaunching.
-    cudaGraphInstantiateFlagAutoFreeOnLaunch = ccudart.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagAutoFreeOnLaunch{{endif}}
-    {{if 'cudaGraphInstantiateFlagUseNodePriority' in found_values}}
+    #: Device supports caching globals in L1
+    cudaDevAttrGlobalL1CacheSupported = cyruntime.cudaDeviceAttr.cudaDevAttrGlobalL1CacheSupported{{endif}}
+    {{if 'cudaDevAttrLocalL1CacheSupported' in found_values}}
 
-    #: Run the graph using the per-node priority attributes rather than the
-    #: priority of the stream it is launched into.
-    cudaGraphInstantiateFlagUseNodePriority = ccudart.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUseNodePriority{{endif}}
-{{endif}}
-{{if 'cudaLaunchAttributeID' in found_types}}
+    #: Device supports caching locals in L1
+    cudaDevAttrLocalL1CacheSupported = cyruntime.cudaDeviceAttr.cudaDevAttrLocalL1CacheSupported{{endif}}
+    {{if 'cudaDevAttrMaxSharedMemoryPerMultiprocessor' in found_values}}
 
-class cudaLaunchAttributeID(IntEnum):
-    """
-    Launch attributes enum; used as id field of
-    :py:obj:`~.cudaLaunchAttribute`
-    """
-    {{if 'cudaLaunchAttributeIgnore' in found_values}}
+    #: Maximum shared memory available per multiprocessor in bytes
+    cudaDevAttrMaxSharedMemoryPerMultiprocessor = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerMultiprocessor{{endif}}
+    {{if 'cudaDevAttrMaxRegistersPerMultiprocessor' in found_values}}
 
-    #: Ignored entry, for convenient composition
-    cudaLaunchAttributeIgnore = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeIgnore{{endif}}
-    {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}}
+    #: Maximum number of 32-bit registers available per multiprocessor
+    cudaDevAttrMaxRegistersPerMultiprocessor = cyruntime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerMultiprocessor{{endif}}
+    {{if 'cudaDevAttrManagedMemory' in found_values}}
 
-    #: Valid for streams, graph nodes, launches.
-    cudaLaunchAttributeAccessPolicyWindow = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow{{endif}}
-    {{if 'cudaLaunchAttributeCooperative' in found_values}}
+    #: Device can allocate managed memory on this system
+    cudaDevAttrManagedMemory = cyruntime.cudaDeviceAttr.cudaDevAttrManagedMemory{{endif}}
+    {{if 'cudaDevAttrIsMultiGpuBoard' in found_values}}
 
-    #: Valid for graph nodes, launches.
-    cudaLaunchAttributeCooperative = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeCooperative{{endif}}
-    {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}}
+    #: Device is on a multi-GPU board
+    cudaDevAttrIsMultiGpuBoard = cyruntime.cudaDeviceAttr.cudaDevAttrIsMultiGpuBoard{{endif}}
+    {{if 'cudaDevAttrMultiGpuBoardGroupID' in found_values}}
 
-    #: Valid for streams.
-    cudaLaunchAttributeSynchronizationPolicy = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy{{endif}}
-    {{if 'cudaLaunchAttributeClusterDimension' in found_values}}
+    #: Unique identifier for a group of devices on the same multi-GPU board
+    cudaDevAttrMultiGpuBoardGroupID = cyruntime.cudaDeviceAttr.cudaDevAttrMultiGpuBoardGroupID{{endif}}
+    {{if 'cudaDevAttrHostNativeAtomicSupported' in found_values}}
 
-    #: Valid for graph nodes, launches.
-    cudaLaunchAttributeClusterDimension = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension{{endif}}
-    {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}}
+    #: Link between the device and the host supports native atomic
+    #: operations
+    cudaDevAttrHostNativeAtomicSupported = cyruntime.cudaDeviceAttr.cudaDevAttrHostNativeAtomicSupported{{endif}}
+    {{if 'cudaDevAttrSingleToDoublePrecisionPerfRatio' in found_values}}
 
-    #: Valid for graph nodes, launches.
-    cudaLaunchAttributeClusterSchedulingPolicyPreference = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference{{endif}}
-    {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}}
+    #: Ratio of single precision performance (in floating-point operations
+    #: per second) to double precision performance
+    cudaDevAttrSingleToDoublePrecisionPerfRatio = cyruntime.cudaDeviceAttr.cudaDevAttrSingleToDoublePrecisionPerfRatio{{endif}}
+    {{if 'cudaDevAttrPageableMemoryAccess' in found_values}}
 
-    #: Valid for launches. Setting programmaticStreamSerializationAllowed
-    #: to non-0 signals that the kernel will use programmatic means to
-    #: resolve its stream dependency, so that the CUDA runtime should
-    #: opportunistically allow the grid's execution to overlap with the
-    #: previous kernel in the stream, if that kernel requests the overlap.
-    cudaLaunchAttributeProgrammaticStreamSerialization = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization{{endif}}
-    {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}}
+    #: Device supports coherently accessing pageable memory without calling
+    #: cudaHostRegister on it
+    cudaDevAttrPageableMemoryAccess = cyruntime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccess{{endif}}
+    {{if 'cudaDevAttrConcurrentManagedAccess' in found_values}}
 
-    #: Valid for launches. Event recorded through this launch attribute is
-    #: guaranteed to only trigger after all block in the associated kernel
-    #: trigger the event. A block can trigger the event through PTX
-    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
-    #: the beginning of each block's execution if triggerAtBlockStart is
-    #: set to non-0. Note that dependents (including the CPU thread calling
-    #: :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to observe
-    #: the release precisely when it is released. For example,
-    #: :py:obj:`~.cudaEventSynchronize()` may only observe the event
-    #: trigger long after the associated kernel has completed. This
-    #: recording type is primarily meant for establishing programmatic
-    #: dependency between device tasks. The event supplied must not be an
-    #: interprocess or interop event. The event must disable timing (i.e.
-    #: created with :py:obj:`~.cudaEventDisableTiming` flag set).
-    cudaLaunchAttributeProgrammaticEvent = ccudart.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent{{endif}}
-    {{if 'cudaLaunchAttributePriority' in found_values}}
+    #: Device can coherently access managed memory concurrently with the
+    #: CPU
+    cudaDevAttrConcurrentManagedAccess = cyruntime.cudaDeviceAttr.cudaDevAttrConcurrentManagedAccess{{endif}}
+    {{if 'cudaDevAttrComputePreemptionSupported' in found_values}}
 
-    #: Valid for graph nodes.
-    cudaLaunchAttributePriority = ccudart.cudaLaunchAttributeID.cudaLaunchAttributePriority{{endif}}
-{{endif}}
-{{if True or 'cudaStreamAttrID' in found_types}}
+    #: Device supports Compute Preemption
+    cudaDevAttrComputePreemptionSupported = cyruntime.cudaDeviceAttr.cudaDevAttrComputePreemptionSupported{{endif}}
+    {{if 'cudaDevAttrCanUseHostPointerForRegisteredMem' in found_values}}
 
-class cudaStreamAttrID(IntEnum):
-    """"""
-    {{if True or 'cudaStreamAttributeAccessPolicyWindow' in found_values}}
-    cudaStreamAttributeAccessPolicyWindow = ccudart.cudaStreamAttrID.cudaStreamAttributeAccessPolicyWindow{{endif}}
-    {{if True or 'cudaStreamAttributeSynchronizationPolicy' in found_values}}
-    cudaStreamAttributeSynchronizationPolicy = ccudart.cudaStreamAttrID.cudaStreamAttributeSynchronizationPolicy{{endif}}
-{{endif}}
-{{if True or 'cudaKernelNodeAttrID' in found_types}}
+    #: Device can access host registered memory at the same virtual address
+    #: as the CPU
+    cudaDevAttrCanUseHostPointerForRegisteredMem = cyruntime.cudaDeviceAttr.cudaDevAttrCanUseHostPointerForRegisteredMem{{endif}}
+    {{if 'cudaDevAttrReserved92' in found_values}}
+    cudaDevAttrReserved92 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved92{{endif}}
+    {{if 'cudaDevAttrReserved93' in found_values}}
+    cudaDevAttrReserved93 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved93{{endif}}
+    {{if 'cudaDevAttrReserved94' in found_values}}
+    cudaDevAttrReserved94 = cyruntime.cudaDeviceAttr.cudaDevAttrReserved94{{endif}}
+    {{if 'cudaDevAttrCooperativeLaunch' in found_values}}
 
-class cudaKernelNodeAttrID(IntEnum):
-    """"""
-    {{if True or 'cudaKernelNodeAttributeAccessPolicyWindow' in found_values}}
-    cudaKernelNodeAttributeAccessPolicyWindow = ccudart.cudaKernelNodeAttrID.cudaKernelNodeAttributeAccessPolicyWindow{{endif}}
-    {{if True or 'cudaKernelNodeAttributeCooperative' in found_values}}
-    cudaKernelNodeAttributeCooperative = ccudart.cudaKernelNodeAttrID.cudaKernelNodeAttributeCooperative{{endif}}
-    {{if True or 'cudaKernelNodeAttributePriority' in found_values}}
-    cudaKernelNodeAttributePriority = ccudart.cudaKernelNodeAttrID.cudaKernelNodeAttributePriority{{endif}}
-{{endif}}
-{{if True or 'cudaGLDeviceList' in found_types}}
+    #: Device supports launching cooperative kernels via
+    #: :py:obj:`~.cudaLaunchCooperativeKernel`
+    cudaDevAttrCooperativeLaunch = cyruntime.cudaDeviceAttr.cudaDevAttrCooperativeLaunch{{endif}}
+    {{if 'cudaDevAttrCooperativeMultiDeviceLaunch' in found_values}}
 
-class cudaGLDeviceList(IntEnum):
-    """
-    CUDA devices corresponding to the current OpenGL context
-    """
-    {{if True or 'cudaGLDeviceListAll' in found_values}}
+    #: Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated.
+    cudaDevAttrCooperativeMultiDeviceLaunch = cyruntime.cudaDeviceAttr.cudaDevAttrCooperativeMultiDeviceLaunch{{endif}}
+    {{if 'cudaDevAttrMaxSharedMemoryPerBlockOptin' in found_values}}
 
-    #: The CUDA devices for all GPUs used by the current OpenGL context
-    cudaGLDeviceListAll = ccudart.cudaGLDeviceList.cudaGLDeviceListAll{{endif}}
-    {{if True or 'cudaGLDeviceListCurrentFrame' in found_values}}
+    #: The maximum optin shared memory per block. This value may vary by
+    #: chip. See :py:obj:`~.cudaFuncSetAttribute`
+    cudaDevAttrMaxSharedMemoryPerBlockOptin = cyruntime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlockOptin{{endif}}
+    {{if 'cudaDevAttrCanFlushRemoteWrites' in found_values}}
 
-    #: The CUDA devices for the GPUs used by the current OpenGL context in
-    #: its currently rendering frame
-    cudaGLDeviceListCurrentFrame = ccudart.cudaGLDeviceList.cudaGLDeviceListCurrentFrame{{endif}}
-    {{if True or 'cudaGLDeviceListNextFrame' in found_values}}
+    #: Device supports flushing of outstanding remote writes.
+    cudaDevAttrCanFlushRemoteWrites = cyruntime.cudaDeviceAttr.cudaDevAttrCanFlushRemoteWrites{{endif}}
+    {{if 'cudaDevAttrHostRegisterSupported' in found_values}}
 
-    #: The CUDA devices for the GPUs to be used by the current OpenGL
-    #: context in the next frame
-    cudaGLDeviceListNextFrame = ccudart.cudaGLDeviceList.cudaGLDeviceListNextFrame{{endif}}
-{{endif}}
-{{if True or 'cudaGLMapFlags' in found_types}}
+    #: Device supports host memory registration via
+    #: :py:obj:`~.cudaHostRegister`.
+    cudaDevAttrHostRegisterSupported = cyruntime.cudaDeviceAttr.cudaDevAttrHostRegisterSupported{{endif}}
+    {{if 'cudaDevAttrPageableMemoryAccessUsesHostPageTables' in found_values}}
 
-class cudaGLMapFlags(IntEnum):
-    """
-    CUDA GL Map Flags
-    """
-    {{if True or 'cudaGLMapFlagsNone' in found_values}}
+    #: Device accesses pageable memory via the host's page tables.
+    cudaDevAttrPageableMemoryAccessUsesHostPageTables = cyruntime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccessUsesHostPageTables{{endif}}
+    {{if 'cudaDevAttrDirectManagedMemAccessFromHost' in found_values}}
 
-    #: Default; Assume resource can be read/written
-    cudaGLMapFlagsNone = ccudart.cudaGLMapFlags.cudaGLMapFlagsNone{{endif}}
-    {{if True or 'cudaGLMapFlagsReadOnly' in found_values}}
+    #: Host can directly access managed memory on the device without
+    #: migration.
+    cudaDevAttrDirectManagedMemAccessFromHost = cyruntime.cudaDeviceAttr.cudaDevAttrDirectManagedMemAccessFromHost{{endif}}
+    {{if 'cudaDevAttrMaxBlocksPerMultiprocessor' in found_values}}
 
-    #: CUDA kernels will not write to this resource
-    cudaGLMapFlagsReadOnly = ccudart.cudaGLMapFlags.cudaGLMapFlagsReadOnly{{endif}}
-    {{if True or 'cudaGLMapFlagsWriteDiscard' in found_values}}
+    #: Maximum number of blocks per multiprocessor
+    cudaDevAttrMaxBlocksPerMultiprocessor = cyruntime.cudaDeviceAttr.cudaDevAttrMaxBlocksPerMultiprocessor{{endif}}
+    {{if 'cudaDevAttrMaxPersistingL2CacheSize' in found_values}}
 
-    #: CUDA kernels will only write to and will not read from this resource
-    cudaGLMapFlagsWriteDiscard = ccudart.cudaGLMapFlags.cudaGLMapFlagsWriteDiscard{{endif}}
-{{endif}}
-{{if 'cudaRoundMode' in found_types}}
+    #: Maximum L2 persisting lines capacity setting in bytes.
+    cudaDevAttrMaxPersistingL2CacheSize = cyruntime.cudaDeviceAttr.cudaDevAttrMaxPersistingL2CacheSize{{endif}}
+    {{if 'cudaDevAttrMaxAccessPolicyWindowSize' in found_values}}
 
-class cudaRoundMode(IntEnum):
-    """"""
-    {{if 'cudaRoundNearest' in found_values}}
-    cudaRoundNearest = ccudart.cudaRoundMode.cudaRoundNearest{{endif}}
-    {{if 'cudaRoundZero' in found_values}}
-    cudaRoundZero = ccudart.cudaRoundMode.cudaRoundZero{{endif}}
-    {{if 'cudaRoundPosInf' in found_values}}
-    cudaRoundPosInf = ccudart.cudaRoundMode.cudaRoundPosInf{{endif}}
-    {{if 'cudaRoundMinInf' in found_values}}
-    cudaRoundMinInf = ccudart.cudaRoundMode.cudaRoundMinInf{{endif}}
-{{endif}}
-{{if 'cudaSurfaceBoundaryMode' in found_types}}
+    #: Maximum value of :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.
+    cudaDevAttrMaxAccessPolicyWindowSize = cyruntime.cudaDeviceAttr.cudaDevAttrMaxAccessPolicyWindowSize{{endif}}
+    {{if 'cudaDevAttrReservedSharedMemoryPerBlock' in found_values}}
 
-class cudaSurfaceBoundaryMode(IntEnum):
-    """
-    CUDA Surface boundary modes
-    """
-    {{if 'cudaBoundaryModeZero' in found_values}}
+    #: Shared memory reserved by CUDA driver per block in bytes
+    cudaDevAttrReservedSharedMemoryPerBlock = cyruntime.cudaDeviceAttr.cudaDevAttrReservedSharedMemoryPerBlock{{endif}}
+    {{if 'cudaDevAttrSparseCudaArraySupported' in found_values}}
 
-    #: Zero boundary mode
-    cudaBoundaryModeZero = ccudart.cudaSurfaceBoundaryMode.cudaBoundaryModeZero{{endif}}
-    {{if 'cudaBoundaryModeClamp' in found_values}}
+    #: Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays
+    cudaDevAttrSparseCudaArraySupported = cyruntime.cudaDeviceAttr.cudaDevAttrSparseCudaArraySupported{{endif}}
+    {{if 'cudaDevAttrHostRegisterReadOnlySupported' in found_values}}
 
-    #: Clamp boundary mode
-    cudaBoundaryModeClamp = ccudart.cudaSurfaceBoundaryMode.cudaBoundaryModeClamp{{endif}}
-    {{if 'cudaBoundaryModeTrap' in found_values}}
+    #: Device supports using the :py:obj:`~.cudaHostRegister` flag
+    #: cudaHostRegisterReadOnly to register memory that must be mapped as
+    #: read-only to the GPU
+    cudaDevAttrHostRegisterReadOnlySupported = cyruntime.cudaDeviceAttr.cudaDevAttrHostRegisterReadOnlySupported{{endif}}
+    {{if 'cudaDevAttrTimelineSemaphoreInteropSupported' in found_values}}
 
-    #: Trap boundary mode
-    cudaBoundaryModeTrap = ccudart.cudaSurfaceBoundaryMode.cudaBoundaryModeTrap{{endif}}
-{{endif}}
-{{if 'cudaSurfaceFormatMode' in found_types}}
+    #: External timeline semaphore interop is supported on the device
+    cudaDevAttrTimelineSemaphoreInteropSupported = cyruntime.cudaDeviceAttr.cudaDevAttrTimelineSemaphoreInteropSupported{{endif}}
+    {{if 'cudaDevAttrMaxTimelineSemaphoreInteropSupported' in found_values}}
 
-class cudaSurfaceFormatMode(IntEnum):
-    """
-    CUDA Surface format modes
-    """
-    {{if 'cudaFormatModeForced' in found_values}}
+    #: Deprecated, External timeline semaphore interop is supported on the
+    #: device
+    cudaDevAttrMaxTimelineSemaphoreInteropSupported = cyruntime.cudaDeviceAttr.cudaDevAttrMaxTimelineSemaphoreInteropSupported{{endif}}
+    {{if 'cudaDevAttrMemoryPoolsSupported' in found_values}}
 
-    #: Forced format mode
-    cudaFormatModeForced = ccudart.cudaSurfaceFormatMode.cudaFormatModeForced{{endif}}
-    {{if 'cudaFormatModeAuto' in found_values}}
+    #: Device supports using the :py:obj:`~.cudaMallocAsync` and
+    #: :py:obj:`~.cudaMemPool` family of APIs
+    cudaDevAttrMemoryPoolsSupported = cyruntime.cudaDeviceAttr.cudaDevAttrMemoryPoolsSupported{{endif}}
+    {{if 'cudaDevAttrGPUDirectRDMASupported' in found_values}}
 
-    #: Auto format mode
-    cudaFormatModeAuto = ccudart.cudaSurfaceFormatMode.cudaFormatModeAuto{{endif}}
-{{endif}}
-{{if 'cudaTextureAddressMode' in found_types}}
+    #: Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see
+    #: https://docs.nvidia.com/cuda/gpudirect-rdma for more information)
+    cudaDevAttrGPUDirectRDMASupported = cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMASupported{{endif}}
+    {{if 'cudaDevAttrGPUDirectRDMAFlushWritesOptions' in found_values}}
 
-class cudaTextureAddressMode(IntEnum):
-    """
-    CUDA texture address modes
-    """
-    {{if 'cudaAddressModeWrap' in found_values}}
+    #: The returned attribute shall be interpreted as a bitmask, where the
+    #: individual bits are listed in the
+    #: :py:obj:`~.cudaFlushGPUDirectRDMAWritesOptions` enum
+    cudaDevAttrGPUDirectRDMAFlushWritesOptions = cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAFlushWritesOptions{{endif}}
+    {{if 'cudaDevAttrGPUDirectRDMAWritesOrdering' in found_values}}
 
-    #: Wrapping address mode
-    cudaAddressModeWrap = ccudart.cudaTextureAddressMode.cudaAddressModeWrap{{endif}}
-    {{if 'cudaAddressModeClamp' in found_values}}
+    #: GPUDirect RDMA writes to the device do not need to be flushed for
+    #: consumers within the scope indicated by the returned attribute. See
+    #: :py:obj:`~.cudaGPUDirectRDMAWritesOrdering` for the numerical values
+    #: returned here.
+    cudaDevAttrGPUDirectRDMAWritesOrdering = cyruntime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAWritesOrdering{{endif}}
+    {{if 'cudaDevAttrMemoryPoolSupportedHandleTypes' in found_values}}
 
-    #: Clamp to edge address mode
-    cudaAddressModeClamp = ccudart.cudaTextureAddressMode.cudaAddressModeClamp{{endif}}
-    {{if 'cudaAddressModeMirror' in found_values}}
+    #: Handle types supported with mempool based IPC
+    cudaDevAttrMemoryPoolSupportedHandleTypes = cyruntime.cudaDeviceAttr.cudaDevAttrMemoryPoolSupportedHandleTypes{{endif}}
+    {{if 'cudaDevAttrClusterLaunch' in found_values}}
 
-    #: Mirror address mode
-    cudaAddressModeMirror = ccudart.cudaTextureAddressMode.cudaAddressModeMirror{{endif}}
-    {{if 'cudaAddressModeBorder' in found_values}}
+    #: Indicates device supports cluster launch
+    cudaDevAttrClusterLaunch = cyruntime.cudaDeviceAttr.cudaDevAttrClusterLaunch{{endif}}
+    {{if 'cudaDevAttrDeferredMappingCudaArraySupported' in found_values}}
 
-    #: Border address mode
-    cudaAddressModeBorder = ccudart.cudaTextureAddressMode.cudaAddressModeBorder{{endif}}
+    #: Device supports deferred mapping CUDA arrays and CUDA mipmapped
+    #: arrays
+    cudaDevAttrDeferredMappingCudaArraySupported = cyruntime.cudaDeviceAttr.cudaDevAttrDeferredMappingCudaArraySupported{{endif}}
+    {{if 'cudaDevAttrMax' in found_values}}
+    cudaDevAttrMax = cyruntime.cudaDeviceAttr.cudaDevAttrMax{{endif}}
 {{endif}}
-{{if 'cudaTextureFilterMode' in found_types}}
+{{if 'cudaMemPoolAttr' in found_types}}
 
-class cudaTextureFilterMode(IntEnum):
+class cudaMemPoolAttr(IntEnum):
     """
-    CUDA texture filter modes
+    CUDA memory pool attributes
     """
-    {{if 'cudaFilterModePoint' in found_values}}
+    {{if 'cudaMemPoolReuseFollowEventDependencies' in found_values}}
 
-    #: Point filter mode
-    cudaFilterModePoint = ccudart.cudaTextureFilterMode.cudaFilterModePoint{{endif}}
-    {{if 'cudaFilterModeLinear' in found_values}}
+    #: (value type = int) Allow cuMemAllocAsync to use memory
+    #: asynchronously freed in another streams as long as a stream ordering
+    #: dependency of the allocating stream on the free action exists. Cuda
+    #: events and null stream interactions can create the required stream
+    #: ordered dependencies. (default enabled)
+    cudaMemPoolReuseFollowEventDependencies = cyruntime.cudaMemPoolAttr.cudaMemPoolReuseFollowEventDependencies{{endif}}
+    {{if 'cudaMemPoolReuseAllowOpportunistic' in found_values}}
 
-    #: Linear filter mode
-    cudaFilterModeLinear = ccudart.cudaTextureFilterMode.cudaFilterModeLinear{{endif}}
+    #: (value type = int) Allow reuse of already completed frees when there
+    #: is no dependency between the free and allocation. (default enabled)
+    cudaMemPoolReuseAllowOpportunistic = cyruntime.cudaMemPoolAttr.cudaMemPoolReuseAllowOpportunistic{{endif}}
+    {{if 'cudaMemPoolReuseAllowInternalDependencies' in found_values}}
+
+    #: (value type = int) Allow cuMemAllocAsync to insert new stream
+    #: dependencies in order to establish the stream ordering required to
+    #: reuse a piece of memory released by cuFreeAsync (default enabled).
+    cudaMemPoolReuseAllowInternalDependencies = cyruntime.cudaMemPoolAttr.cudaMemPoolReuseAllowInternalDependencies{{endif}}
+    {{if 'cudaMemPoolAttrReleaseThreshold' in found_values}}
+
+    #: (value type = cuuint64_t) Amount of reserved memory in bytes to hold
+    #: onto before trying to release memory back to the OS. When more than
+    #: the release threshold bytes of memory are held by the memory pool,
+    #: the allocator will try to release memory back to the OS on the next
+    #: call to stream, event or context synchronize. (default 0)
+    cudaMemPoolAttrReleaseThreshold = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReleaseThreshold{{endif}}
+    {{if 'cudaMemPoolAttrReservedMemCurrent' in found_values}}
+
+    #: (value type = cuuint64_t) Amount of backing memory currently
+    #: allocated for the mempool.
+    cudaMemPoolAttrReservedMemCurrent = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemCurrent{{endif}}
+    {{if 'cudaMemPoolAttrReservedMemHigh' in found_values}}
+
+    #: (value type = cuuint64_t) High watermark of backing memory allocated
+    #: for the mempool since the last time it was reset. High watermark can
+    #: only be reset to zero.
+    cudaMemPoolAttrReservedMemHigh = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemHigh{{endif}}
+    {{if 'cudaMemPoolAttrUsedMemCurrent' in found_values}}
+
+    #: (value type = cuuint64_t) Amount of memory from the pool that is
+    #: currently in use by the application.
+    cudaMemPoolAttrUsedMemCurrent = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemCurrent{{endif}}
+    {{if 'cudaMemPoolAttrUsedMemHigh' in found_values}}
+
+    #: (value type = cuuint64_t) High watermark of the amount of memory
+    #: from the pool that was in use by the application since the last time
+    #: it was reset. High watermark can only be reset to zero.
+    cudaMemPoolAttrUsedMemHigh = cyruntime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemHigh{{endif}}
 {{endif}}
-{{if 'cudaTextureReadMode' in found_types}}
+{{if 'cudaMemLocationType' in found_types}}
 
-class cudaTextureReadMode(IntEnum):
+class cudaMemLocationType(IntEnum):
     """
-    CUDA texture read modes
+    Specifies the type of location
     """
-    {{if 'cudaReadModeElementType' in found_values}}
-
-    #: Read texture as specified element type
-    cudaReadModeElementType = ccudart.cudaTextureReadMode.cudaReadModeElementType{{endif}}
-    {{if 'cudaReadModeNormalizedFloat' in found_values}}
+    {{if 'cudaMemLocationTypeInvalid' in found_values}}
+    cudaMemLocationTypeInvalid = cyruntime.cudaMemLocationType.cudaMemLocationTypeInvalid{{endif}}
+    {{if 'cudaMemLocationTypeDevice' in found_values}}
 
-    #: Read texture as normalized float
-    cudaReadModeNormalizedFloat = ccudart.cudaTextureReadMode.cudaReadModeNormalizedFloat{{endif}}
+    #: Location is a device location, thus id is a device ordinal
+    cudaMemLocationTypeDevice = cyruntime.cudaMemLocationType.cudaMemLocationTypeDevice{{endif}}
 {{endif}}
-{{if 'cudaDataType_t' in found_types}}
-
-class cudaDataType(IntEnum):
-    """"""
-    {{if 'CUDA_R_16F' in found_values}}
-    CUDA_R_16F = ccudart.cudaDataType_t.CUDA_R_16F{{endif}}
-    {{if 'CUDA_C_16F' in found_values}}
-    CUDA_C_16F = ccudart.cudaDataType_t.CUDA_C_16F{{endif}}
-    {{if 'CUDA_R_16BF' in found_values}}
-    CUDA_R_16BF = ccudart.cudaDataType_t.CUDA_R_16BF{{endif}}
-    {{if 'CUDA_C_16BF' in found_values}}
-    CUDA_C_16BF = ccudart.cudaDataType_t.CUDA_C_16BF{{endif}}
-    {{if 'CUDA_R_32F' in found_values}}
-    CUDA_R_32F = ccudart.cudaDataType_t.CUDA_R_32F{{endif}}
-    {{if 'CUDA_C_32F' in found_values}}
-    CUDA_C_32F = ccudart.cudaDataType_t.CUDA_C_32F{{endif}}
-    {{if 'CUDA_R_64F' in found_values}}
-    CUDA_R_64F = ccudart.cudaDataType_t.CUDA_R_64F{{endif}}
-    {{if 'CUDA_C_64F' in found_values}}
-    CUDA_C_64F = ccudart.cudaDataType_t.CUDA_C_64F{{endif}}
-    {{if 'CUDA_R_4I' in found_values}}
-    CUDA_R_4I = ccudart.cudaDataType_t.CUDA_R_4I{{endif}}
-    {{if 'CUDA_C_4I' in found_values}}
-    CUDA_C_4I = ccudart.cudaDataType_t.CUDA_C_4I{{endif}}
-    {{if 'CUDA_R_4U' in found_values}}
-    CUDA_R_4U = ccudart.cudaDataType_t.CUDA_R_4U{{endif}}
-    {{if 'CUDA_C_4U' in found_values}}
-    CUDA_C_4U = ccudart.cudaDataType_t.CUDA_C_4U{{endif}}
-    {{if 'CUDA_R_8I' in found_values}}
-    CUDA_R_8I = ccudart.cudaDataType_t.CUDA_R_8I{{endif}}
-    {{if 'CUDA_C_8I' in found_values}}
-    CUDA_C_8I = ccudart.cudaDataType_t.CUDA_C_8I{{endif}}
-    {{if 'CUDA_R_8U' in found_values}}
-    CUDA_R_8U = ccudart.cudaDataType_t.CUDA_R_8U{{endif}}
-    {{if 'CUDA_C_8U' in found_values}}
-    CUDA_C_8U = ccudart.cudaDataType_t.CUDA_C_8U{{endif}}
-    {{if 'CUDA_R_16I' in found_values}}
-    CUDA_R_16I = ccudart.cudaDataType_t.CUDA_R_16I{{endif}}
-    {{if 'CUDA_C_16I' in found_values}}
-    CUDA_C_16I = ccudart.cudaDataType_t.CUDA_C_16I{{endif}}
-    {{if 'CUDA_R_16U' in found_values}}
-    CUDA_R_16U = ccudart.cudaDataType_t.CUDA_R_16U{{endif}}
-    {{if 'CUDA_C_16U' in found_values}}
-    CUDA_C_16U = ccudart.cudaDataType_t.CUDA_C_16U{{endif}}
-    {{if 'CUDA_R_32I' in found_values}}
-    CUDA_R_32I = ccudart.cudaDataType_t.CUDA_R_32I{{endif}}
-    {{if 'CUDA_C_32I' in found_values}}
-    CUDA_C_32I = ccudart.cudaDataType_t.CUDA_C_32I{{endif}}
-    {{if 'CUDA_R_32U' in found_values}}
-    CUDA_R_32U = ccudart.cudaDataType_t.CUDA_R_32U{{endif}}
-    {{if 'CUDA_C_32U' in found_values}}
-    CUDA_C_32U = ccudart.cudaDataType_t.CUDA_C_32U{{endif}}
-    {{if 'CUDA_R_64I' in found_values}}
-    CUDA_R_64I = ccudart.cudaDataType_t.CUDA_R_64I{{endif}}
-    {{if 'CUDA_C_64I' in found_values}}
-    CUDA_C_64I = ccudart.cudaDataType_t.CUDA_C_64I{{endif}}
-    {{if 'CUDA_R_64U' in found_values}}
-    CUDA_R_64U = ccudart.cudaDataType_t.CUDA_R_64U{{endif}}
-    {{if 'CUDA_C_64U' in found_values}}
-    CUDA_C_64U = ccudart.cudaDataType_t.CUDA_C_64U{{endif}}
-    {{if 'CUDA_R_8F_E4M3' in found_values}}
-    CUDA_R_8F_E4M3 = ccudart.cudaDataType_t.CUDA_R_8F_E4M3{{endif}}
-    {{if 'CUDA_R_8F_E5M2' in found_values}}
-    CUDA_R_8F_E5M2 = ccudart.cudaDataType_t.CUDA_R_8F_E5M2{{endif}}
-{{endif}}
-{{if 'libraryPropertyType_t' in found_types}}
-
-class libraryPropertyType(IntEnum):
-    """"""
-    {{if 'MAJOR_VERSION' in found_values}}
-    MAJOR_VERSION = ccudart.libraryPropertyType_t.MAJOR_VERSION{{endif}}
-    {{if 'MINOR_VERSION' in found_values}}
-    MINOR_VERSION = ccudart.libraryPropertyType_t.MINOR_VERSION{{endif}}
-    {{if 'PATCH_LEVEL' in found_values}}
-    PATCH_LEVEL = ccudart.libraryPropertyType_t.PATCH_LEVEL{{endif}}
-{{endif}}
-{{if True or 'cudaEglFrameType_enum' in found_types}}
+{{if 'cudaMemAccessFlags' in found_types}}
 
-class cudaEglFrameType(IntEnum):
+class cudaMemAccessFlags(IntEnum):
     """
-    CUDA EglFrame type - array or pointer
+    Specifies the memory protection flags for mapping.
     """
-    {{if True or 'cudaEglFrameTypeArray' in found_values}}
+    {{if 'cudaMemAccessFlagsProtNone' in found_values}}
 
-    #: Frame type CUDA array
-    cudaEglFrameTypeArray = ccudart.cudaEglFrameType_enum.cudaEglFrameTypeArray{{endif}}
-    {{if True or 'cudaEglFrameTypePitch' in found_values}}
+    #: Default, make the address range not accessible
+    cudaMemAccessFlagsProtNone = cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtNone{{endif}}
+    {{if 'cudaMemAccessFlagsProtRead' in found_values}}
 
-    #: Frame type CUDA pointer
-    cudaEglFrameTypePitch = ccudart.cudaEglFrameType_enum.cudaEglFrameTypePitch{{endif}}
+    #: Make the address range read accessible
+    cudaMemAccessFlagsProtRead = cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtRead{{endif}}
+    {{if 'cudaMemAccessFlagsProtReadWrite' in found_values}}
+
+    #: Make the address range read-write accessible
+    cudaMemAccessFlagsProtReadWrite = cyruntime.cudaMemAccessFlags.cudaMemAccessFlagsProtReadWrite{{endif}}
 {{endif}}
-{{if True or 'cudaEglResourceLocationFlags_enum' in found_types}}
+{{if 'cudaMemAllocationType' in found_types}}
 
-class cudaEglResourceLocationFlags(IntEnum):
+class cudaMemAllocationType(IntEnum):
     """
-    Resource location flags- sysmem or vidmem  For CUDA context on
-    iGPU, since video and system memory are equivalent - these flags
-    will not have an effect on the execution.  For CUDA context on
-    dGPU, applications can use the flag
-    :py:obj:`~.cudaEglResourceLocationFlags` to give a hint about the
-    desired location.  :py:obj:`~.cudaEglResourceLocationSysmem` - the
-    frame data is made resident on the system memory to be accessed by
-    CUDA.  :py:obj:`~.cudaEglResourceLocationVidmem` - the frame data
-    is made resident on the dedicated video memory to be accessed by
-    CUDA.  There may be an additional latency due to new allocation and
-    data migration, if the frame is produced on a different memory.
+    Defines the allocation types available
     """
-    {{if True or 'cudaEglResourceLocationSysmem' in found_values}}
-
-    #: Resource location sysmem
-    cudaEglResourceLocationSysmem = ccudart.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationSysmem{{endif}}
-    {{if True or 'cudaEglResourceLocationVidmem' in found_values}}
+    {{if 'cudaMemAllocationTypeInvalid' in found_values}}
+    cudaMemAllocationTypeInvalid = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeInvalid{{endif}}
+    {{if 'cudaMemAllocationTypePinned' in found_values}}
 
-    #: Resource location vidmem
-    cudaEglResourceLocationVidmem = ccudart.cudaEglResourceLocationFlags_enum.cudaEglResourceLocationVidmem{{endif}}
+    #: This allocation type is 'pinned', i.e. cannot migrate from its
+    #: current location while the application is actively using it
+    cudaMemAllocationTypePinned = cyruntime.cudaMemAllocationType.cudaMemAllocationTypePinned{{endif}}
+    {{if 'cudaMemAllocationTypeMax' in found_values}}
+    cudaMemAllocationTypeMax = cyruntime.cudaMemAllocationType.cudaMemAllocationTypeMax{{endif}}
 {{endif}}
-{{if True or 'cudaEglColorFormat_enum' in found_types}}
+{{if 'cudaMemAllocationHandleType' in found_types}}
 
-class cudaEglColorFormat(IntEnum):
+class cudaMemAllocationHandleType(IntEnum):
     """
-    CUDA EGL Color Format - The different planar and multiplanar
-    formats currently supported for CUDA_EGL interops.
+    Flags for specifying particular handle types
     """
-    {{if True or 'cudaEglColorFormatYUV420Planar' in found_values}}
+    {{if 'cudaMemHandleTypeNone' in found_values}}
 
-    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420SemiPlanar' in found_values}}
+    #: Does not allow any export mechanism. >
+    cudaMemHandleTypeNone = cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeNone{{endif}}
+    {{if 'cudaMemHandleTypePosixFileDescriptor' in found_values}}
 
-    #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
-    #: width, height ratio same as YUV420Planar.
-    cudaEglColorFormatYUV420SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatYUV422Planar' in found_values}}
+    #: Allows a file descriptor to be used for exporting. Permitted only on
+    #: POSIX systems. (int)
+    cudaMemHandleTypePosixFileDescriptor = cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypePosixFileDescriptor{{endif}}
+    {{if 'cudaMemHandleTypeWin32' in found_values}}
 
-    #: Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V
-    #: height = Y height.
-    cudaEglColorFormatYUV422Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar{{endif}}
-    {{if True or 'cudaEglColorFormatYUV422SemiPlanar' in found_values}}
+    #: Allows a Win32 NT handle to be used for exporting. (HANDLE)
+    cudaMemHandleTypeWin32 = cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32{{endif}}
+    {{if 'cudaMemHandleTypeWin32Kmt' in found_values}}
 
-    #: Y, UV in two surfaces with VU byte ordering, width, height ratio
-    #: same as YUV422Planar.
-    cudaEglColorFormatYUV422SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatARGB' in found_values}}
+    #: Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)
+    cudaMemHandleTypeWin32Kmt = cyruntime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32Kmt{{endif}}
+{{endif}}
+{{if 'cudaGraphMemAttributeType' in found_types}}
 
-    #: R/G/B/A four channels in one surface with BGRA byte ordering.
-    cudaEglColorFormatARGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatARGB{{endif}}
-    {{if True or 'cudaEglColorFormatRGBA' in found_values}}
+class cudaGraphMemAttributeType(IntEnum):
+    """
+    Graph memory attributes
+    """
+    {{if 'cudaGraphMemAttrUsedMemCurrent' in found_values}}
 
-    #: R/G/B/A four channels in one surface with ABGR byte ordering.
-    cudaEglColorFormatRGBA = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatRGBA{{endif}}
-    {{if True or 'cudaEglColorFormatL' in found_values}}
+    #: (value type = cuuint64_t) Amount of memory, in bytes, currently
+    #: associated with graphs.
+    cudaGraphMemAttrUsedMemCurrent = cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemCurrent{{endif}}
+    {{if 'cudaGraphMemAttrUsedMemHigh' in found_values}}
 
-    #: single luminance channel in one surface.
-    cudaEglColorFormatL = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatL{{endif}}
-    {{if True or 'cudaEglColorFormatR' in found_values}}
+    #: (value type = cuuint64_t) High watermark of memory, in bytes,
+    #: associated with graphs since the last time it was reset. High
+    #: watermark can only be reset to zero.
+    cudaGraphMemAttrUsedMemHigh = cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemHigh{{endif}}
+    {{if 'cudaGraphMemAttrReservedMemCurrent' in found_values}}
 
-    #: single color channel in one surface.
-    cudaEglColorFormatR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatR{{endif}}
-    {{if True or 'cudaEglColorFormatYUV444Planar' in found_values}}
+    #: (value type = cuuint64_t) Amount of memory, in bytes, currently
+    #: allocated for use by the CUDA graphs asynchronous allocator.
+    cudaGraphMemAttrReservedMemCurrent = cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemCurrent{{endif}}
+    {{if 'cudaGraphMemAttrReservedMemHigh' in found_values}}
 
-    #: Y, U, V in three surfaces, each in a separate surface, U/V width = Y
-    #: width, U/V height = Y height.
-    cudaEglColorFormatYUV444Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar{{endif}}
-    {{if True or 'cudaEglColorFormatYUV444SemiPlanar' in found_values}}
+    #: (value type = cuuint64_t) High watermark of memory, in bytes,
+    #: currently allocated for use by the CUDA graphs asynchronous
+    #: allocator.
+    cudaGraphMemAttrReservedMemHigh = cyruntime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemHigh{{endif}}
+{{endif}}
+{{if 'cudaDeviceP2PAttr' in found_types}}
 
-    #: Y, UV in two surfaces (UV as one surface) with VU byte ordering,
-    #: width, height ratio same as YUV444Planar.
-    cudaEglColorFormatYUV444SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatYUYV422' in found_values}}
+class cudaDeviceP2PAttr(IntEnum):
+    """
+    CUDA device P2P attributes
+    """
+    {{if 'cudaDevP2PAttrPerformanceRank' in found_values}}
 
-    #: Y, U, V in one surface, interleaved as UYVY in one channel.
-    cudaEglColorFormatYUYV422 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUYV422{{endif}}
-    {{if True or 'cudaEglColorFormatUYVY422' in found_values}}
+    #: A relative value indicating the performance of the link between two
+    #: devices
+    cudaDevP2PAttrPerformanceRank = cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrPerformanceRank{{endif}}
+    {{if 'cudaDevP2PAttrAccessSupported' in found_values}}
 
-    #: Y, U, V in one surface, interleaved as YUYV in one channel.
-    cudaEglColorFormatUYVY422 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatUYVY422{{endif}}
-    {{if True or 'cudaEglColorFormatABGR' in found_values}}
+    #: Peer access is enabled
+    cudaDevP2PAttrAccessSupported = cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrAccessSupported{{endif}}
+    {{if 'cudaDevP2PAttrNativeAtomicSupported' in found_values}}
 
-    #: R/G/B/A four channels in one surface with RGBA byte ordering.
-    cudaEglColorFormatABGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatABGR{{endif}}
-    {{if True or 'cudaEglColorFormatBGRA' in found_values}}
+    #: Native atomic operation over the link supported
+    cudaDevP2PAttrNativeAtomicSupported = cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrNativeAtomicSupported{{endif}}
+    {{if 'cudaDevP2PAttrCudaArrayAccessSupported' in found_values}}
 
-    #: R/G/B/A four channels in one surface with ARGB byte ordering.
-    cudaEglColorFormatBGRA = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBGRA{{endif}}
-    {{if True or 'cudaEglColorFormatA' in found_values}}
+    #: Accessing CUDA arrays over the link supported
+    cudaDevP2PAttrCudaArrayAccessSupported = cyruntime.cudaDeviceP2PAttr.cudaDevP2PAttrCudaArrayAccessSupported{{endif}}
+{{endif}}
+{{if 'cudaExternalMemoryHandleType' in found_types}}
 
-    #: Alpha color format - one channel in one surface.
-    cudaEglColorFormatA = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatA{{endif}}
-    {{if True or 'cudaEglColorFormatRG' in found_values}}
+class cudaExternalMemoryHandleType(IntEnum):
+    """
+    External memory handle types
+    """
+    {{if 'cudaExternalMemoryHandleTypeOpaqueFd' in found_values}}
 
-    #: R/G color format - two channels in one surface with GR byte ordering
-    cudaEglColorFormatRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatRG{{endif}}
-    {{if True or 'cudaEglColorFormatAYUV' in found_values}}
+    #: Handle is an opaque file descriptor
+    cudaExternalMemoryHandleTypeOpaqueFd = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeOpaqueWin32' in found_values}}
 
-    #: Y, U, V, A four channels in one surface, interleaved as VUYA.
-    cudaEglColorFormatAYUV = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatAYUV{{endif}}
-    {{if True or 'cudaEglColorFormatYVU444SemiPlanar' in found_values}}
+    #: Handle is an opaque shared NT handle
+    cudaExternalMemoryHandleTypeOpaqueWin32 = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeOpaqueWin32Kmt' in found_values}}
 
-    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
-    #: width = Y width, U/V height = Y height.
-    cudaEglColorFormatYVU444SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatYVU422SemiPlanar' in found_values}}
+    #: Handle is an opaque, globally shared handle
+    cudaExternalMemoryHandleTypeOpaqueWin32Kmt = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeD3D12Heap' in found_values}}
 
-    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
-    #: width = 1/2 Y width, U/V height = Y height.
-    cudaEglColorFormatYVU422SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420SemiPlanar' in found_values}}
+    #: Handle is a D3D12 heap object
+    cudaExternalMemoryHandleTypeD3D12Heap = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeD3D12Resource' in found_values}}
 
-    #: Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V
-    #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_444SemiPlanar' in found_values}}
+    #: Handle is a D3D12 committed resource
+    cudaExternalMemoryHandleTypeD3D12Resource = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeD3D11Resource' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
-    #: ordering, U/V width = Y width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_444SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_420SemiPlanar' in found_values}}
+    #: Handle is a shared NT handle to a D3D11 resource
+    cudaExternalMemoryHandleTypeD3D11Resource = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeD3D11ResourceKmt' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) with UV byte
-    #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY10V10U10_420SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_444SemiPlanar' in found_values}}
+    #: Handle is a globally shared handle to a D3D11 resource
+    cudaExternalMemoryHandleTypeD3D11ResourceKmt = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt{{endif}}
+    {{if 'cudaExternalMemoryHandleTypeNvSciBuf' in found_values}}
 
-    #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
-    #: ordering, U/V width = Y width, U/V height = Y height.
-    cudaEglColorFormatY12V12U12_444SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_420SemiPlanar' in found_values}}
+    #: Handle is an NvSciBuf object
+    cudaExternalMemoryHandleTypeNvSciBuf = cyruntime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf{{endif}}
+{{endif}}
+{{if 'cudaExternalSemaphoreHandleType' in found_types}}
 
-    #: Y12, V12U12 in two surfaces (VU as one surface) with UV byte
-    #: ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY12V12U12_420SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatVYUY_ER' in found_values}}
+class cudaExternalSemaphoreHandleType(IntEnum):
+    """
+    External semaphore handle types
+    """
+    {{if 'cudaExternalSemaphoreHandleTypeOpaqueFd' in found_values}}
 
-    #: Extended Range Y, U, V in one surface, interleaved as YVYU in one
-    #: channel.
-    cudaEglColorFormatVYUY_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatVYUY_ER{{endif}}
-    {{if True or 'cudaEglColorFormatUYVY_ER' in found_values}}
+    #: Handle is an opaque file descriptor
+    cudaExternalSemaphoreHandleTypeOpaqueFd = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32' in found_values}}
 
-    #: Extended Range Y, U, V in one surface, interleaved as YUYV in one
-    #: channel.
-    cudaEglColorFormatUYVY_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatUYVY_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUYV_ER' in found_values}}
+    #: Handle is an opaque shared NT handle
+    cudaExternalSemaphoreHandleTypeOpaqueWin32 = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt' in found_values}}
 
-    #: Extended Range Y, U, V in one surface, interleaved as UYVY in one
-    #: channel.
-    cudaEglColorFormatYUYV_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUYV_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVYU_ER' in found_values}}
+    #: Handle is an opaque, globally shared handle
+    cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeD3D12Fence' in found_values}}
 
-    #: Extended Range Y, U, V in one surface, interleaved as VYUY in one
-    #: channel.
-    cudaEglColorFormatYVYU_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVYU_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUVA_ER' in found_values}}
+    #: Handle is a shared NT handle referencing a D3D12 fence object
+    cudaExternalSemaphoreHandleTypeD3D12Fence = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeD3D11Fence' in found_values}}
 
-    #: Extended Range Y, U, V, A four channels in one surface, interleaved
-    #: as AVUY.
-    cudaEglColorFormatYUVA_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUVA_ER{{endif}}
-    {{if True or 'cudaEglColorFormatAYUV_ER' in found_values}}
+    #: Handle is a shared NT handle referencing a D3D11 fence object
+    cudaExternalSemaphoreHandleTypeD3D11Fence = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeNvSciSync' in found_values}}
 
-    #: Extended Range Y, U, V, A four channels in one surface, interleaved
-    #: as VUYA.
-    cudaEglColorFormatAYUV_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatAYUV_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV444Planar_ER' in found_values}}
+    #: Opaque handle to NvSciSync Object
+    cudaExternalSemaphoreHandleTypeNvSciSync = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeKeyedMutex' in found_values}}
 
-    #: Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V
-    #: height = Y height.
-    cudaEglColorFormatYUV444Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV444Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV422Planar_ER' in found_values}}
+    #: Handle is a shared NT handle referencing a D3D11 keyed mutex object
+    cudaExternalSemaphoreHandleTypeKeyedMutex = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeKeyedMutexKmt' in found_values}}
 
-    #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
-    #: U/V height = Y height.
-    cudaEglColorFormatYUV422Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV422Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420Planar_ER' in found_values}}
+    #: Handle is a shared KMT handle referencing a D3D11 keyed mutex object
+    cudaExternalSemaphoreHandleTypeKeyedMutexKmt = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd' in found_values}}
 
-    #: Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV444SemiPlanar_ER' in found_values}}
+    #: Handle is an opaque handle file descriptor referencing a timeline
+    #: semaphore
+    cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd{{endif}}
+    {{if 'cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32' in found_values}}
 
-    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
-    #: byte ordering, U/V width = Y width, U/V height = Y height.
-    cudaEglColorFormatYUV444SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV444SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV422SemiPlanar_ER' in found_values}}
+    #: Handle is an opaque handle file descriptor referencing a timeline
+    #: semaphore
+    cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32 = cyruntime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32{{endif}}
+{{endif}}
+{{if 'cudaCGScope' in found_types}}
 
-    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
-    #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
-    cudaEglColorFormatYUV422SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV422SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420SemiPlanar_ER' in found_values}}
+class cudaCGScope(IntEnum):
+    """
+    CUDA cooperative group scope
+    """
+    {{if 'cudaCGScopeInvalid' in found_values}}
 
-    #: Extended Range Y, UV in two surfaces (UV as one surface) with VU
-    #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU444Planar_ER' in found_values}}
+    #: Invalid cooperative group scope
+    cudaCGScopeInvalid = cyruntime.cudaCGScope.cudaCGScopeInvalid{{endif}}
+    {{if 'cudaCGScopeGrid' in found_values}}
 
-    #: Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V
-    #: height = Y height.
-    cudaEglColorFormatYVU444Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU422Planar_ER' in found_values}}
+    #: Scope represented by a grid_group
+    cudaCGScopeGrid = cyruntime.cudaCGScope.cudaCGScopeGrid{{endif}}
+    {{if 'cudaCGScopeMultiGrid' in found_values}}
 
-    #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
-    #: U/V height = Y height.
-    cudaEglColorFormatYVU422Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420Planar_ER' in found_values}}
+    #: Scope represented by a multi_grid_group
+    cudaCGScopeMultiGrid = cyruntime.cudaCGScope.cudaCGScopeMultiGrid{{endif}}
+{{endif}}
+{{if 'cudaGraphNodeType' in found_types}}
 
-    #: Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420Planar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU444SemiPlanar_ER' in found_values}}
+class cudaGraphNodeType(IntEnum):
+    """
+    CUDA Graph node types
+    """
+    {{if 'cudaGraphNodeTypeKernel' in found_values}}
 
-    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
-    #: byte ordering, U/V width = Y width, U/V height = Y height.
-    cudaEglColorFormatYVU444SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU444SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU422SemiPlanar_ER' in found_values}}
+    #: GPU kernel node
+    cudaGraphNodeTypeKernel = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeKernel{{endif}}
+    {{if 'cudaGraphNodeTypeMemcpy' in found_values}}
 
-    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
-    #: byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
-    cudaEglColorFormatYVU422SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU422SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420SemiPlanar_ER' in found_values}}
+    #: Memcpy node
+    cudaGraphNodeTypeMemcpy = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemcpy{{endif}}
+    {{if 'cudaGraphNodeTypeMemset' in found_values}}
 
-    #: Extended Range Y, VU in two surfaces (VU as one surface) with UV
-    #: byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatBayerRGGB' in found_values}}
+    #: Memset node
+    cudaGraphNodeTypeMemset = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemset{{endif}}
+    {{if 'cudaGraphNodeTypeHost' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved RGGB
-    #: ordering.
-    cudaEglColorFormatBayerRGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerRGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayerBGGR' in found_values}}
+    #: Host (executable) node
+    cudaGraphNodeTypeHost = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeHost{{endif}}
+    {{if 'cudaGraphNodeTypeGraph' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved BGGR
-    #: ordering.
-    cudaEglColorFormatBayerBGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerBGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayerGRBG' in found_values}}
+    #: Node which executes an embedded graph
+    cudaGraphNodeTypeGraph = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeGraph{{endif}}
+    {{if 'cudaGraphNodeTypeEmpty' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved GRBG
-    #: ordering.
-    cudaEglColorFormatBayerGRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerGRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayerGBRG' in found_values}}
+    #: Empty (no-op) node
+    cudaGraphNodeTypeEmpty = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeEmpty{{endif}}
+    {{if 'cudaGraphNodeTypeWaitEvent' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved GBRG
-    #: ordering.
-    cudaEglColorFormatBayerGBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerGBRG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer10RGGB' in found_values}}
+    #: External event wait node
+    cudaGraphNodeTypeWaitEvent = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeWaitEvent{{endif}}
+    {{if 'cudaGraphNodeTypeEventRecord' in found_values}}
 
-    #: Bayer10 format - one channel in one surface with interleaved RGGB
-    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    cudaEglColorFormatBayer10RGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer10RGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayer10BGGR' in found_values}}
+    #: External event record node
+    cudaGraphNodeTypeEventRecord = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeEventRecord{{endif}}
+    {{if 'cudaGraphNodeTypeExtSemaphoreSignal' in found_values}}
 
-    #: Bayer10 format - one channel in one surface with interleaved BGGR
-    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    cudaEglColorFormatBayer10BGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer10BGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayer10GRBG' in found_values}}
+    #: External semaphore signal node
+    cudaGraphNodeTypeExtSemaphoreSignal = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreSignal{{endif}}
+    {{if 'cudaGraphNodeTypeExtSemaphoreWait' in found_values}}
 
-    #: Bayer10 format - one channel in one surface with interleaved GRBG
-    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    cudaEglColorFormatBayer10GRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer10GBRG' in found_values}}
+    #: External semaphore wait node
+    cudaGraphNodeTypeExtSemaphoreWait = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreWait{{endif}}
+    {{if 'cudaGraphNodeTypeMemAlloc' in found_values}}
 
-    #: Bayer10 format - one channel in one surface with interleaved GBRG
-    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    cudaEglColorFormatBayer10GBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer10GBRG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12RGGB' in found_values}}
+    #: Memory allocation node
+    cudaGraphNodeTypeMemAlloc = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemAlloc{{endif}}
+    {{if 'cudaGraphNodeTypeMemFree' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved RGGB
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12RGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12BGGR' in found_values}}
+    #: Memory free node
+    cudaGraphNodeTypeMemFree = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeMemFree{{endif}}
+    {{if 'cudaGraphNodeTypeCount' in found_values}}
+    cudaGraphNodeTypeCount = cyruntime.cudaGraphNodeType.cudaGraphNodeTypeCount{{endif}}
+{{endif}}
+{{if 'cudaGraphExecUpdateResult' in found_types}}
 
-    #: Bayer12 format - one channel in one surface with interleaved BGGR
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12BGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12GRBG' in found_values}}
+class cudaGraphExecUpdateResult(IntEnum):
+    """
+    CUDA Graph Update error types
+    """
+    {{if 'cudaGraphExecUpdateSuccess' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved GRBG
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12GRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12GBRG' in found_values}}
+    #: The update succeeded
+    cudaGraphExecUpdateSuccess = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateSuccess{{endif}}
+    {{if 'cudaGraphExecUpdateError' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved GBRG
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12GBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12GBRG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer14RGGB' in found_values}}
+    #: The update failed for an unexpected reason which is described in the
+    #: return value of the function
+    cudaGraphExecUpdateError = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateError{{endif}}
+    {{if 'cudaGraphExecUpdateErrorTopologyChanged' in found_values}}
 
-    #: Bayer14 format - one channel in one surface with interleaved RGGB
-    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    cudaEglColorFormatBayer14RGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer14RGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayer14BGGR' in found_values}}
+    #: The update failed because the topology changed
+    cudaGraphExecUpdateErrorTopologyChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorTopologyChanged{{endif}}
+    {{if 'cudaGraphExecUpdateErrorNodeTypeChanged' in found_values}}
 
-    #: Bayer14 format - one channel in one surface with interleaved BGGR
-    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    cudaEglColorFormatBayer14BGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer14BGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayer14GRBG' in found_values}}
+    #: The update failed because a node type changed
+    cudaGraphExecUpdateErrorNodeTypeChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNodeTypeChanged{{endif}}
+    {{if 'cudaGraphExecUpdateErrorFunctionChanged' in found_values}}
 
-    #: Bayer14 format - one channel in one surface with interleaved GRBG
-    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    cudaEglColorFormatBayer14GRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer14GBRG' in found_values}}
+    #: The update failed because the function of a kernel node changed
+    #: (CUDA driver < 11.2)
+    cudaGraphExecUpdateErrorFunctionChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorFunctionChanged{{endif}}
+    {{if 'cudaGraphExecUpdateErrorParametersChanged' in found_values}}
 
-    #: Bayer14 format - one channel in one surface with interleaved GBRG
-    #: ordering. Out of 16 bits, 14 bits used 2 bits No-op.
-    cudaEglColorFormatBayer14GBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer14GBRG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer20RGGB' in found_values}}
+    #: The update failed because the parameters changed in a way that is
+    #: not supported
+    cudaGraphExecUpdateErrorParametersChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorParametersChanged{{endif}}
+    {{if 'cudaGraphExecUpdateErrorNotSupported' in found_values}}
 
-    #: Bayer20 format - one channel in one surface with interleaved RGGB
-    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    cudaEglColorFormatBayer20RGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer20RGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayer20BGGR' in found_values}}
+    #: The update failed because something about the node is not supported
+    cudaGraphExecUpdateErrorNotSupported = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNotSupported{{endif}}
+    {{if 'cudaGraphExecUpdateErrorUnsupportedFunctionChange' in found_values}}
 
-    #: Bayer20 format - one channel in one surface with interleaved BGGR
-    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    cudaEglColorFormatBayer20BGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer20BGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayer20GRBG' in found_values}}
+    #: The update failed because the function of a kernel node changed in
+    #: an unsupported way
+    cudaGraphExecUpdateErrorUnsupportedFunctionChange = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorUnsupportedFunctionChange{{endif}}
+    {{if 'cudaGraphExecUpdateErrorAttributesChanged' in found_values}}
 
-    #: Bayer20 format - one channel in one surface with interleaved GRBG
-    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    cudaEglColorFormatBayer20GRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayer20GBRG' in found_values}}
+    #: The update failed because the node attributes changed in a way that
+    #: is not supported
+    cudaGraphExecUpdateErrorAttributesChanged = cyruntime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorAttributesChanged{{endif}}
+{{endif}}
+{{if 'cudaGetDriverEntryPointFlags' in found_types}}
 
-    #: Bayer20 format - one channel in one surface with interleaved GBRG
-    #: ordering. Out of 32 bits, 20 bits used 12 bits No-op.
-    cudaEglColorFormatBayer20GBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer20GBRG{{endif}}
-    {{if True or 'cudaEglColorFormatYVU444Planar' in found_values}}
+class cudaGetDriverEntryPointFlags(IntEnum):
+    """
+    Flags to specify search options to be used with
+    :py:obj:`~.cudaGetDriverEntryPoint` For more details see
+    :py:obj:`~.cuGetProcAddress`
+    """
+    {{if 'cudaEnableDefault' in found_values}}
 
-    #: Y, V, U in three surfaces, each in a separate surface, U/V width = Y
-    #: width, U/V height = Y height.
-    cudaEglColorFormatYVU444Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU444Planar{{endif}}
-    {{if True or 'cudaEglColorFormatYVU422Planar' in found_values}}
+    #: Default search mode for driver symbols.
+    cudaEnableDefault = cyruntime.cudaGetDriverEntryPointFlags.cudaEnableDefault{{endif}}
+    {{if 'cudaEnableLegacyStream' in found_values}}
 
-    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = Y height.
-    cudaEglColorFormatYVU422Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU422Planar{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420Planar' in found_values}}
+    #: Search for legacy versions of driver symbols.
+    cudaEnableLegacyStream = cyruntime.cudaGetDriverEntryPointFlags.cudaEnableLegacyStream{{endif}}
+    {{if 'cudaEnablePerThreadDefaultStream' in found_values}}
 
-    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420Planar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar{{endif}}
-    {{if True or 'cudaEglColorFormatBayerIspRGGB' in found_values}}
+    #: Search for per-thread versions of driver symbols.
+    cudaEnablePerThreadDefaultStream = cyruntime.cudaGetDriverEntryPointFlags.cudaEnablePerThreadDefaultStream{{endif}}
+{{endif}}
+{{if 'cudaGraphDebugDotFlags' in found_types}}
 
-    #: Nvidia proprietary Bayer ISP format - one channel in one surface
-    #: with interleaved RGGB ordering and mapped to opaque integer
-    #: datatype.
-    cudaEglColorFormatBayerIspRGGB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspRGGB{{endif}}
-    {{if True or 'cudaEglColorFormatBayerIspBGGR' in found_values}}
+class cudaGraphDebugDotFlags(IntEnum):
+    """
+    CUDA Graph debug write options
+    """
+    {{if 'cudaGraphDebugDotFlagsVerbose' in found_values}}
 
-    #: Nvidia proprietary Bayer ISP format - one channel in one surface
-    #: with interleaved BGGR ordering and mapped to opaque integer
-    #: datatype.
-    cudaEglColorFormatBayerIspBGGR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspBGGR{{endif}}
-    {{if True or 'cudaEglColorFormatBayerIspGRBG' in found_values}}
+    #: Output all debug data as if every debug flag is enabled
+    cudaGraphDebugDotFlagsVerbose = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsVerbose{{endif}}
+    {{if 'cudaGraphDebugDotFlagsKernelNodeParams' in found_values}}
 
-    #: Nvidia proprietary Bayer ISP format - one channel in one surface
-    #: with interleaved GRBG ordering and mapped to opaque integer
-    #: datatype.
-    cudaEglColorFormatBayerIspGRBG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGRBG{{endif}}
-    {{if True or 'cudaEglColorFormatBayerIspGBRG' in found_values}}
+    #: Adds :py:obj:`~.cudaKernelNodeParams` to output
+    cudaGraphDebugDotFlagsKernelNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsMemcpyNodeParams' in found_values}}
 
-    #: Nvidia proprietary Bayer ISP format - one channel in one surface
-    #: with interleaved GBRG ordering and mapped to opaque integer
-    #: datatype.
-    cudaEglColorFormatBayerIspGBRG = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerIspGBRG{{endif}}
-    {{if True or 'cudaEglColorFormatBayerBCCR' in found_values}}
+    #: Adds :py:obj:`~.cudaMemcpy3DParms` to output
+    cudaGraphDebugDotFlagsMemcpyNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemcpyNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsMemsetNodeParams' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved BCCR
-    #: ordering.
-    cudaEglColorFormatBayerBCCR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerBCCR{{endif}}
-    {{if True or 'cudaEglColorFormatBayerRCCB' in found_values}}
+    #: Adds :py:obj:`~.cudaMemsetParams` to output
+    cudaGraphDebugDotFlagsMemsetNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemsetNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsHostNodeParams' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved RCCB
-    #: ordering.
-    cudaEglColorFormatBayerRCCB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerRCCB{{endif}}
-    {{if True or 'cudaEglColorFormatBayerCRBC' in found_values}}
+    #: Adds :py:obj:`~.cudaHostNodeParams` to output
+    cudaGraphDebugDotFlagsHostNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHostNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsEventNodeParams' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved CRBC
-    #: ordering.
-    cudaEglColorFormatBayerCRBC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerCRBC{{endif}}
-    {{if True or 'cudaEglColorFormatBayerCBRC' in found_values}}
+    #: Adds cudaEvent_t handle from record and wait nodes to output
+    cudaGraphDebugDotFlagsEventNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsEventNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsExtSemasSignalNodeParams' in found_values}}
 
-    #: Bayer format - one channel in one surface with interleaved CBRC
-    #: ordering.
-    cudaEglColorFormatBayerCBRC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayerCBRC{{endif}}
-    {{if True or 'cudaEglColorFormatBayer10CCCC' in found_values}}
+    #: Adds :py:obj:`~.cudaExternalSemaphoreSignalNodeParams` values to
+    #: output
+    cudaGraphDebugDotFlagsExtSemasSignalNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasSignalNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsExtSemasWaitNodeParams' in found_values}}
 
-    #: Bayer10 format - one channel in one surface with interleaved CCCC
-    #: ordering. Out of 16 bits, 10 bits used 6 bits No-op.
-    cudaEglColorFormatBayer10CCCC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer10CCCC{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12BCCR' in found_values}}
+    #: Adds :py:obj:`~.cudaExternalSemaphoreWaitNodeParams` to output
+    cudaGraphDebugDotFlagsExtSemasWaitNodeParams = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasWaitNodeParams{{endif}}
+    {{if 'cudaGraphDebugDotFlagsKernelNodeAttributes' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved BCCR
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12BCCR = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12BCCR{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12RCCB' in found_values}}
+    #: Adds cudaKernelNodeAttrID values to output
+    cudaGraphDebugDotFlagsKernelNodeAttributes = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeAttributes{{endif}}
+    {{if 'cudaGraphDebugDotFlagsHandles' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved RCCB
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12RCCB = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12RCCB{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12CRBC' in found_values}}
+    #: Adds node handles and every kernel function handle to output
+    cudaGraphDebugDotFlagsHandles = cyruntime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHandles{{endif}}
+{{endif}}
+{{if 'cudaGraphInstantiateFlags' in found_types}}
 
-    #: Bayer12 format - one channel in one surface with interleaved CRBC
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12CRBC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CRBC{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12CBRC' in found_values}}
+class cudaGraphInstantiateFlags(IntEnum):
+    """
+    Flags for instantiating a graph
+    """
+    {{if 'cudaGraphInstantiateFlagAutoFreeOnLaunch' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved CBRC
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12CBRC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CBRC{{endif}}
-    {{if True or 'cudaEglColorFormatBayer12CCCC' in found_values}}
+    #: Automatically free memory allocated in a graph before relaunching.
+    cudaGraphInstantiateFlagAutoFreeOnLaunch = cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagAutoFreeOnLaunch{{endif}}
+    {{if 'cudaGraphInstantiateFlagUseNodePriority' in found_values}}
 
-    #: Bayer12 format - one channel in one surface with interleaved CCCC
-    #: ordering. Out of 16 bits, 12 bits used 4 bits No-op.
-    cudaEglColorFormatBayer12CCCC = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatBayer12CCCC{{endif}}
-    {{if True or 'cudaEglColorFormatY' in found_values}}
+    #: Run the graph using the per-node priority attributes rather than the
+    #: priority of the stream it is launched into.
+    cudaGraphInstantiateFlagUseNodePriority = cyruntime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUseNodePriority{{endif}}
+{{endif}}
+{{if 'cudaSurfaceBoundaryMode' in found_types}}
 
-    #: Color format for single Y plane.
-    cudaEglColorFormatY = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420SemiPlanar_2020' in found_values}}
+class cudaSurfaceBoundaryMode(IntEnum):
+    """
+    CUDA Surface boundary modes
+    """
+    {{if 'cudaBoundaryModeZero' in found_values}}
 
-    #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420SemiPlanar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420SemiPlanar_2020' in found_values}}
+    #: Zero boundary mode
+    cudaBoundaryModeZero = cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeZero{{endif}}
+    {{if 'cudaBoundaryModeClamp' in found_values}}
 
-    #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420SemiPlanar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420Planar_2020' in found_values}}
+    #: Clamp boundary mode
+    cudaBoundaryModeClamp = cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeClamp{{endif}}
+    {{if 'cudaBoundaryModeTrap' in found_values}}
 
-    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420Planar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420Planar_2020' in found_values}}
+    #: Trap boundary mode
+    cudaBoundaryModeTrap = cyruntime.cudaSurfaceBoundaryMode.cudaBoundaryModeTrap{{endif}}
+{{endif}}
+{{if 'cudaSurfaceFormatMode' in found_types}}
 
-    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420Planar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420SemiPlanar_709' in found_values}}
+class cudaSurfaceFormatMode(IntEnum):
+    """
+    CUDA Surface format modes
+    """
+    {{if 'cudaFormatModeForced' in found_values}}
 
-    #: Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420SemiPlanar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420SemiPlanar_709{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420SemiPlanar_709' in found_values}}
+    #: Forced format mode
+    cudaFormatModeForced = cyruntime.cudaSurfaceFormatMode.cudaFormatModeForced{{endif}}
+    {{if 'cudaFormatModeAuto' in found_values}}
 
-    #: Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width,
-    #: U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420SemiPlanar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420SemiPlanar_709{{endif}}
-    {{if True or 'cudaEglColorFormatYUV420Planar_709' in found_values}}
+    #: Auto format mode
+    cudaFormatModeAuto = cyruntime.cudaSurfaceFormatMode.cudaFormatModeAuto{{endif}}
+{{endif}}
+{{if 'cudaTextureAddressMode' in found_types}}
 
-    #: Y, U, V in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYUV420Planar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUV420Planar_709{{endif}}
-    {{if True or 'cudaEglColorFormatYVU420Planar_709' in found_values}}
+class cudaTextureAddressMode(IntEnum):
+    """
+    CUDA texture address modes
+    """
+    {{if 'cudaAddressModeWrap' in found_values}}
 
-    #: Y, V, U in three surfaces, each in a separate surface, U/V width =
-    #: 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatYVU420Planar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVU420Planar_709{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_420SemiPlanar_709' in found_values}}
+    #: Wrapping address mode
+    cudaAddressModeWrap = cyruntime.cudaTextureAddressMode.cudaAddressModeWrap{{endif}}
+    {{if 'cudaAddressModeClamp' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
-    #: width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY10V10U10_420SemiPlanar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_420SemiPlanar_2020' in found_values}}
+    #: Clamp to edge address mode
+    cudaAddressModeClamp = cyruntime.cudaTextureAddressMode.cudaAddressModeClamp{{endif}}
+    {{if 'cudaAddressModeMirror' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
-    #: width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY10V10U10_420SemiPlanar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_422SemiPlanar_2020' in found_values}}
+    #: Mirror address mode
+    cudaAddressModeMirror = cyruntime.cudaTextureAddressMode.cudaAddressModeMirror{{endif}}
+    {{if 'cudaAddressModeBorder' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
-    #: width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_422SemiPlanar_2020 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_2020{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_422SemiPlanar' in found_values}}
+    #: Border address mode
+    cudaAddressModeBorder = cyruntime.cudaTextureAddressMode.cudaAddressModeBorder{{endif}}
+{{endif}}
+{{if 'cudaTextureFilterMode' in found_types}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
-    #: width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_422SemiPlanar = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_422SemiPlanar_709' in found_values}}
+class cudaTextureFilterMode(IntEnum):
+    """
+    CUDA texture filter modes
+    """
+    {{if 'cudaFilterModePoint' in found_values}}
 
-    #: Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y
-    #: width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_422SemiPlanar_709 = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_422SemiPlanar_709{{endif}}
-    {{if True or 'cudaEglColorFormatY_ER' in found_values}}
+    #: Point filter mode
+    cudaFilterModePoint = cyruntime.cudaTextureFilterMode.cudaFilterModePoint{{endif}}
+    {{if 'cudaFilterModeLinear' in found_values}}
 
-    #: Extended Range Color format for single Y plane.
-    cudaEglColorFormatY_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY_709_ER' in found_values}}
+    #: Linear filter mode
+    cudaFilterModeLinear = cyruntime.cudaTextureFilterMode.cudaFilterModeLinear{{endif}}
+{{endif}}
+{{if 'cudaTextureReadMode' in found_types}}
 
-    #: Extended Range Color format for single Y plane.
-    cudaEglColorFormatY_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY10_ER' in found_values}}
+class cudaTextureReadMode(IntEnum):
+    """
+    CUDA texture read modes
+    """
+    {{if 'cudaReadModeElementType' in found_values}}
 
-    #: Extended Range Color format for single Y10 plane.
-    cudaEglColorFormatY10_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY10_709_ER' in found_values}}
+    #: Read texture as specified element type
+    cudaReadModeElementType = cyruntime.cudaTextureReadMode.cudaReadModeElementType{{endif}}
+    {{if 'cudaReadModeNormalizedFloat' in found_values}}
 
-    #: Extended Range Color format for single Y10 plane.
-    cudaEglColorFormatY10_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12_ER' in found_values}}
+    #: Read texture as normalized float
+    cudaReadModeNormalizedFloat = cyruntime.cudaTextureReadMode.cudaReadModeNormalizedFloat{{endif}}
+{{endif}}
+{{if 'cudaRoundMode' in found_types}}
 
-    #: Extended Range Color format for single Y12 plane.
-    cudaEglColorFormatY12_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12_709_ER' in found_values}}
+class cudaRoundMode(IntEnum):
+    """"""
+    {{if 'cudaRoundNearest' in found_values}}
+    cudaRoundNearest = cyruntime.cudaRoundMode.cudaRoundNearest{{endif}}
+    {{if 'cudaRoundZero' in found_values}}
+    cudaRoundZero = cyruntime.cudaRoundMode.cudaRoundZero{{endif}}
+    {{if 'cudaRoundPosInf' in found_values}}
+    cudaRoundPosInf = cyruntime.cudaRoundMode.cudaRoundPosInf{{endif}}
+    {{if 'cudaRoundMinInf' in found_values}}
+    cudaRoundMinInf = cyruntime.cudaRoundMode.cudaRoundMinInf{{endif}}
+{{endif}}
+{{if True}}
 
-    #: Extended Range Color format for single Y12 plane.
-    cudaEglColorFormatY12_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatYUVA' in found_values}}
+class cudaGLDeviceList(IntEnum):
+    """
+    CUDA devices corresponding to the current OpenGL context
+    """
+    {{if True}}
 
-    #: Y, U, V, A four channels in one surface, interleaved as AVUY.
-    cudaEglColorFormatYUVA = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYUVA{{endif}}
-    {{if True or 'cudaEglColorFormatYVYU' in found_values}}
+    #: The CUDA devices for all GPUs used by the current OpenGL context
+    cudaGLDeviceListAll = cyruntime.cudaGLDeviceList.cudaGLDeviceListAll{{endif}}
+    {{if True}}
 
-    #: Y, U, V in one surface, interleaved as YVYU in one channel.
-    cudaEglColorFormatYVYU = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatYVYU{{endif}}
-    {{if True or 'cudaEglColorFormatVYUY' in found_values}}
+    #: The CUDA devices for the GPUs used by the current OpenGL context in
+    #: its currently rendering frame
+    cudaGLDeviceListCurrentFrame = cyruntime.cudaGLDeviceList.cudaGLDeviceListCurrentFrame{{endif}}
+    {{if True}}
 
-    #: Y, U, V in one surface, interleaved as VYUY in one channel.
-    cudaEglColorFormatVYUY = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatVYUY{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_420SemiPlanar_ER' in found_values}}
+    #: The CUDA devices for the GPUs to be used by the current OpenGL
+    #: context in the next frame
+    cudaGLDeviceListNextFrame = cyruntime.cudaGLDeviceList.cudaGLDeviceListNextFrame{{endif}}
+{{endif}}
+{{if True}}
 
-    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
-    #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY10V10U10_420SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER' in found_values}}
+class cudaGLMapFlags(IntEnum):
+    """
+    CUDA GL Map Flags
+    """
+    {{if True}}
 
-    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
-    #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_444SemiPlanar_ER' in found_values}}
+    #: Default; Assume resource can be read/written
+    cudaGLMapFlagsNone = cyruntime.cudaGLMapFlags.cudaGLMapFlagsNone{{endif}}
+    {{if True}}
 
-    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
-    #: width = Y width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_444SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER' in found_values}}
+    #: CUDA kernels will not write to this resource
+    cudaGLMapFlagsReadOnly = cyruntime.cudaGLMapFlags.cudaGLMapFlagsReadOnly{{endif}}
+    {{if True}}
 
-    #: Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V
-    #: width = Y width, U/V height = Y height.
-    cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_420SemiPlanar_ER' in found_values}}
+    #: CUDA kernels will only write to and will not read from this resource
+    cudaGLMapFlagsWriteDiscard = cyruntime.cudaGLMapFlags.cudaGLMapFlagsWriteDiscard{{endif}}
+{{endif}}
+{{if 'cudaLaunchAttributeID' in found_types}}
 
-    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
-    #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY12V12U12_420SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER' in found_values}}
+class cudaStreamAttrID(IntEnum):
+    """
+    Launch attributes enum; used as id field of
+    :py:obj:`~.cudaLaunchAttribute`
+    """
+    {{if 'cudaLaunchAttributeIgnore' in found_values}}
 
-    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
-    #: width = 1/2 Y width, U/V height = 1/2 Y height.
-    cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_444SemiPlanar_ER' in found_values}}
+    #: Ignored entry, for convenient composition
+    cudaLaunchAttributeIgnore = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore{{endif}}
+    {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}}
 
-    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
-    #: width = Y width, U/V height = Y height.
-    cudaEglColorFormatY12V12U12_444SemiPlanar_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_ER{{endif}}
-    {{if True or 'cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER' in found_values}}
+    #: Valid for streams, graph nodes, launches.
+    cudaLaunchAttributeAccessPolicyWindow = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow{{endif}}
+    {{if 'cudaLaunchAttributeCooperative' in found_values}}
 
-    #: Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V
-    #: width = Y width, U/V height = Y height.
-    cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER = ccudart.cudaEglColorFormat_enum.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER{{endif}}
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeCooperative = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative{{endif}}
+    {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}}
+
+    #: Valid for streams.
+    cudaLaunchAttributeSynchronizationPolicy = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy{{endif}}
+    {{if 'cudaLaunchAttributeClusterDimension' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterDimension = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension{{endif}}
+    {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterSchedulingPolicyPreference = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}}
+
+    #: Valid for launches. Setting programmaticStreamSerializationAllowed
+    #: to non-0 signals that the kernel will use programmatic means to
+    #: resolve its stream dependency, so that the CUDA runtime should
+    #: opportunistically allow the grid's execution to overlap with the
+    #: previous kernel in the stream, if that kernel requests the overlap.
+    cudaLaunchAttributeProgrammaticStreamSerialization = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}}
+
+    #: Valid for launches. Event recorded through this launch attribute is
+    #: guaranteed to only trigger after all block in the associated kernel
+    #: trigger the event. A block can trigger the event through PTX
+    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
+    #: the beginning of each block's execution if triggerAtBlockStart is
+    #: set to non-0. Note that dependents (including the CPU thread calling
+    #: :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to observe
+    #: the release precisely when it is released. For example,
+    #: :py:obj:`~.cudaEventSynchronize()` may only observe the event
+    #: trigger long after the associated kernel has completed. This
+    #: recording type is primarily meant for establishing programmatic
+    #: dependency between device tasks. The event supplied must not be an
+    #: interprocess or interop event. The event must disable timing (i.e.
+    #: created with :py:obj:`~.cudaEventDisableTiming` flag set).
+    cudaLaunchAttributeProgrammaticEvent = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent{{endif}}
+    {{if 'cudaLaunchAttributePriority' in found_values}}
+
+    #: Valid for graph nodes.
+    cudaLaunchAttributePriority = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority{{endif}}
+{{endif}}
+{{if 'cudaLaunchAttributeID' in found_types}}
+
+class cudaKernelNodeAttrID(IntEnum):
+    """
+    Launch attributes enum; used as id field of
+    :py:obj:`~.cudaLaunchAttribute`
+    """
+    {{if 'cudaLaunchAttributeIgnore' in found_values}}
+
+    #: Ignored entry, for convenient composition
+    cudaLaunchAttributeIgnore = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore{{endif}}
+    {{if 'cudaLaunchAttributeAccessPolicyWindow' in found_values}}
+
+    #: Valid for streams, graph nodes, launches.
+    cudaLaunchAttributeAccessPolicyWindow = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow{{endif}}
+    {{if 'cudaLaunchAttributeCooperative' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeCooperative = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative{{endif}}
+    {{if 'cudaLaunchAttributeSynchronizationPolicy' in found_values}}
+
+    #: Valid for streams.
+    cudaLaunchAttributeSynchronizationPolicy = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy{{endif}}
+    {{if 'cudaLaunchAttributeClusterDimension' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterDimension = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension{{endif}}
+    {{if 'cudaLaunchAttributeClusterSchedulingPolicyPreference' in found_values}}
+
+    #: Valid for graph nodes, launches.
+    cudaLaunchAttributeClusterSchedulingPolicyPreference = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticStreamSerialization' in found_values}}
+
+    #: Valid for launches. Setting programmaticStreamSerializationAllowed
+    #: to non-0 signals that the kernel will use programmatic means to
+    #: resolve its stream dependency, so that the CUDA runtime should
+    #: opportunistically allow the grid's execution to overlap with the
+    #: previous kernel in the stream, if that kernel requests the overlap.
+    cudaLaunchAttributeProgrammaticStreamSerialization = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization{{endif}}
+    {{if 'cudaLaunchAttributeProgrammaticEvent' in found_values}}
+
+    #: Valid for launches. Event recorded through this launch attribute is
+    #: guaranteed to only trigger after all block in the associated kernel
+    #: trigger the event. A block can trigger the event through PTX
+    #: griddepcontrol.launch_dependents. A trigger can also be inserted at
+    #: the beginning of each block's execution if triggerAtBlockStart is
+    #: set to non-0. Note that dependents (including the CPU thread calling
+    #: :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to observe
+    #: the release precisely when it is released. For example,
+    #: :py:obj:`~.cudaEventSynchronize()` may only observe the event
+    #: trigger long after the associated kernel has completed. This
+    #: recording type is primarily meant for establishing programmatic
+    #: dependency between device tasks. The event supplied must not be an
+    #: interprocess or interop event. The event must disable timing (i.e.
+    #: created with :py:obj:`~.cudaEventDisableTiming` flag set).
+    cudaLaunchAttributeProgrammaticEvent = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent{{endif}}
+    {{if 'cudaLaunchAttributePriority' in found_values}}
+
+    #: Valid for graph nodes.
+    cudaLaunchAttributePriority = cyruntime.cudaLaunchAttributeID.cudaLaunchAttributePriority{{endif}}
 {{endif}}
 {{if 'cudaArray_t' in found_types}}
 
@@ -3790,9 +3903,9 @@ cdef class cudaArray_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaArray_t>init_value
+            self._ptr[0] = <cyruntime.cudaArray_t>init_value
         else:
-            self._ptr = <ccudart.cudaArray_t *>_ptr
+            self._ptr = <cyruntime.cudaArray_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3821,9 +3934,9 @@ cdef class cudaArray_const_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaArray_const_t>init_value
+            self._ptr[0] = <cyruntime.cudaArray_const_t>init_value
         else:
-            self._ptr = <ccudart.cudaArray_const_t *>_ptr
+            self._ptr = <cyruntime.cudaArray_const_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3852,9 +3965,9 @@ cdef class cudaMipmappedArray_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaMipmappedArray_t>init_value
+            self._ptr[0] = <cyruntime.cudaMipmappedArray_t>init_value
         else:
-            self._ptr = <ccudart.cudaMipmappedArray_t *>_ptr
+            self._ptr = <cyruntime.cudaMipmappedArray_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3883,9 +3996,9 @@ cdef class cudaMipmappedArray_const_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaMipmappedArray_const_t>init_value
+            self._ptr[0] = <cyruntime.cudaMipmappedArray_const_t>init_value
         else:
-            self._ptr = <ccudart.cudaMipmappedArray_const_t *>_ptr
+            self._ptr = <cyruntime.cudaMipmappedArray_const_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3914,9 +4027,9 @@ cdef class cudaGraphicsResource_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaGraphicsResource_t>init_value
+            self._ptr[0] = <cyruntime.cudaGraphicsResource_t>init_value
         else:
-            self._ptr = <ccudart.cudaGraphicsResource_t *>_ptr
+            self._ptr = <cyruntime.cudaGraphicsResource_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3945,9 +4058,9 @@ cdef class cudaExternalMemory_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaExternalMemory_t>init_value
+            self._ptr[0] = <cyruntime.cudaExternalMemory_t>init_value
         else:
-            self._ptr = <ccudart.cudaExternalMemory_t *>_ptr
+            self._ptr = <cyruntime.cudaExternalMemory_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3976,9 +4089,9 @@ cdef class cudaExternalSemaphore_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaExternalSemaphore_t>init_value
+            self._ptr[0] = <cyruntime.cudaExternalSemaphore_t>init_value
         else:
-            self._ptr = <ccudart.cudaExternalSemaphore_t *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphore_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -3991,7 +4104,7 @@ cdef class cudaExternalSemaphore_t:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLImageKHR' in found_types}}
+{{if True}}
 
 cdef class EGLImageKHR:
     """
@@ -4005,9 +4118,9 @@ cdef class EGLImageKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.EGLImageKHR>init_value
+            self._ptr[0] = <cyruntime.EGLImageKHR>init_value
         else:
-            self._ptr = <ccudart.EGLImageKHR *>_ptr
+            self._ptr = <cyruntime.EGLImageKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4020,7 +4133,7 @@ cdef class EGLImageKHR:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLStreamKHR' in found_types}}
+{{if True}}
 
 cdef class EGLStreamKHR:
     """
@@ -4034,9 +4147,9 @@ cdef class EGLStreamKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.EGLStreamKHR>init_value
+            self._ptr[0] = <cyruntime.EGLStreamKHR>init_value
         else:
-            self._ptr = <ccudart.EGLStreamKHR *>_ptr
+            self._ptr = <cyruntime.EGLStreamKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4049,7 +4162,7 @@ cdef class EGLStreamKHR:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLSyncKHR' in found_types}}
+{{if True}}
 
 cdef class EGLSyncKHR:
     """
@@ -4063,9 +4176,9 @@ cdef class EGLSyncKHR:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.EGLSyncKHR>init_value
+            self._ptr[0] = <cyruntime.EGLSyncKHR>init_value
         else:
-            self._ptr = <ccudart.EGLSyncKHR *>_ptr
+            self._ptr = <cyruntime.EGLSyncKHR *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4092,9 +4205,9 @@ cdef class cudaHostFn_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaHostFn_t>init_value
+            self._ptr[0] = <cyruntime.cudaHostFn_t>init_value
         else:
-            self._ptr = <ccudart.cudaHostFn_t *>_ptr
+            self._ptr = <cyruntime.cudaHostFn_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4121,9 +4234,9 @@ cdef class cudaStreamCallback_t:
     def __cinit__(self, void_ptr init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
-            self._ptr[0] = <ccudart.cudaStreamCallback_t>init_value
+            self._ptr[0] = <cyruntime.cudaStreamCallback_t>init_value
         else:
-            self._ptr = <ccudart.cudaStreamCallback_t *>_ptr
+            self._ptr = <cyruntime.cudaStreamCallback_t *>_ptr
     def __init__(self, *args, **kwargs):
         pass
     def __repr__(self):
@@ -4136,11 +4249,10 @@ cdef class cudaStreamCallback_t:
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'dim3' in found_types}}
+{{if 'struct dim3' in found_types}}
 
 cdef class dim3:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -4160,7 +4272,7 @@ cdef class dim3:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.dim3 *>_ptr
+            self._ptr = <cyruntime.dim3 *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4170,36 +4282,41 @@ cdef class dim3:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['x : ' + str(self.x)]
-            str_list += ['y : ' + str(self.y)]
-            str_list += ['z : ' + str(self.z)]
+            try:
+                str_list += ['x : ' + str(self.x)]
+            except ValueError:
+                str_list += ['x : <ValueError>']
+            try:
+                str_list += ['y : ' + str(self.y)]
+            except ValueError:
+                str_list += ['y : <ValueError>']
+            try:
+                str_list += ['z : ' + str(self.z)]
+            except ValueError:
+                str_list += ['z : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def x(self):
         return self._ptr[0].x
     @x.setter
     def x(self, unsigned int x):
-        pass
         self._ptr[0].x = x
     @property
     def y(self):
         return self._ptr[0].y
     @y.setter
     def y(self, unsigned int y):
-        pass
         self._ptr[0].y = y
     @property
     def z(self):
         return self._ptr[0].z
     @z.setter
     def z(self, unsigned int z):
-        pass
         self._ptr[0].z = z
 {{endif}}
-{{if True or 'cudaChannelFormatDesc' in found_types}}
+{{if 'struct cudaChannelFormatDesc' in found_types}}
 
 cdef class cudaChannelFormatDesc:
     """
@@ -4228,7 +4345,7 @@ cdef class cudaChannelFormatDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaChannelFormatDesc *>_ptr
+            self._ptr = <cyruntime.cudaChannelFormatDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4238,56 +4355,64 @@ cdef class cudaChannelFormatDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['x : ' + str(self.x)]
-            str_list += ['y : ' + str(self.y)]
-            str_list += ['z : ' + str(self.z)]
-            str_list += ['w : ' + str(self.w)]
-            str_list += ['f : ' + str(self.f)]
+            try:
+                str_list += ['x : ' + str(self.x)]
+            except ValueError:
+                str_list += ['x : <ValueError>']
+            try:
+                str_list += ['y : ' + str(self.y)]
+            except ValueError:
+                str_list += ['y : <ValueError>']
+            try:
+                str_list += ['z : ' + str(self.z)]
+            except ValueError:
+                str_list += ['z : <ValueError>']
+            try:
+                str_list += ['w : ' + str(self.w)]
+            except ValueError:
+                str_list += ['w : <ValueError>']
+            try:
+                str_list += ['f : ' + str(self.f)]
+            except ValueError:
+                str_list += ['f : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def x(self):
         return self._ptr[0].x
     @x.setter
     def x(self, int x):
-        pass
         self._ptr[0].x = x
     @property
     def y(self):
         return self._ptr[0].y
     @y.setter
     def y(self, int y):
-        pass
         self._ptr[0].y = y
     @property
     def z(self):
         return self._ptr[0].z
     @z.setter
     def z(self, int z):
-        pass
         self._ptr[0].z = z
     @property
     def w(self):
         return self._ptr[0].w
     @w.setter
     def w(self, int w):
-        pass
         self._ptr[0].w = w
     @property
     def f(self):
         return cudaChannelFormatKind(self._ptr[0].f)
     @f.setter
     def f(self, f not None : cudaChannelFormatKind):
-        pass
         self._ptr[0].f = f.value
 {{endif}}
-{{if 'cudaArraySparseProperties' in found_types}}
+{{if 'struct cudaArraySparseProperties' in found_types}}
 
-cdef class _cudaArraySparseProperties_tileExtent_s:
+cdef class anon_struct0:
     """
-
     Attributes
     ----------
     width : unsigned int
@@ -4304,44 +4429,52 @@ cdef class _cudaArraySparseProperties_tileExtent_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaArraySparseProperties *>_ptr
+        self._ptr = <cyruntime.cudaArraySparseProperties *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].tileExtent
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def width(self):
         return self._ptr[0].tileExtent.width
     @width.setter
     def width(self, unsigned int width):
-        pass
         self._ptr[0].tileExtent.width = width
     @property
     def height(self):
         return self._ptr[0].tileExtent.height
     @height.setter
     def height(self, unsigned int height):
-        pass
         self._ptr[0].tileExtent.height = height
     @property
     def depth(self):
         return self._ptr[0].tileExtent.depth
     @depth.setter
     def depth(self, unsigned int depth):
-        pass
         self._ptr[0].tileExtent.depth = depth
 {{endif}}
-{{if 'cudaArraySparseProperties' in found_types}}
+{{if 'struct cudaArraySparseProperties' in found_types}}
 
 cdef class cudaArraySparseProperties:
     """
@@ -4349,7 +4482,7 @@ cdef class cudaArraySparseProperties:
 
     Attributes
     ----------
-    tileExtent : _cudaArraySparseProperties_tileExtent_s
+    tileExtent : anon_struct0
 
     miptailFirstLevel : unsigned int
         First mip level at which the mip tail begins
@@ -4370,9 +4503,9 @@ cdef class cudaArraySparseProperties:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaArraySparseProperties *>_ptr
+            self._ptr = <cyruntime.cudaArraySparseProperties *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._tileExtent = _cudaArraySparseProperties_tileExtent_s(_ptr=<void_ptr>self._ptr)
+        self._tileExtent = anon_struct0(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -4380,56 +4513,61 @@ cdef class cudaArraySparseProperties:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['tileExtent :\n' + '\n'.join(['    ' + line for line in str(self.tileExtent).splitlines()])]
-            str_list += ['miptailFirstLevel : ' + str(self.miptailFirstLevel)]
-            str_list += ['miptailSize : ' + str(self.miptailSize)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['tileExtent :\n' + '\n'.join(['    ' + line for line in str(self.tileExtent).splitlines()])]
+            except ValueError:
+                str_list += ['tileExtent : <ValueError>']
+            try:
+                str_list += ['miptailFirstLevel : ' + str(self.miptailFirstLevel)]
+            except ValueError:
+                str_list += ['miptailFirstLevel : <ValueError>']
+            try:
+                str_list += ['miptailSize : ' + str(self.miptailSize)]
+            except ValueError:
+                str_list += ['miptailSize : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def tileExtent(self):
         return self._tileExtent
     @tileExtent.setter
-    def tileExtent(self, tileExtent not None : _cudaArraySparseProperties_tileExtent_s):
-        pass
-        for _attr in dir(tileExtent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._tileExtent, _attr, getattr(tileExtent, _attr))
+    def tileExtent(self, tileExtent not None : anon_struct0):
+        string.memcpy(&self._ptr[0].tileExtent, <cyruntime.anon_struct0*><void_ptr>tileExtent.getPtr(), sizeof(self._ptr[0].tileExtent))
     @property
     def miptailFirstLevel(self):
         return self._ptr[0].miptailFirstLevel
     @miptailFirstLevel.setter
     def miptailFirstLevel(self, unsigned int miptailFirstLevel):
-        pass
         self._ptr[0].miptailFirstLevel = miptailFirstLevel
     @property
     def miptailSize(self):
         return self._ptr[0].miptailSize
     @miptailSize.setter
     def miptailSize(self, unsigned long long miptailSize):
-        pass
         self._ptr[0].miptailSize = miptailSize
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'cudaArrayMemoryRequirements' in found_types}}
+{{if 'struct cudaArrayMemoryRequirements' in found_types}}
 
 cdef class cudaArrayMemoryRequirements:
     """
@@ -4454,7 +4592,7 @@ cdef class cudaArrayMemoryRequirements:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaArrayMemoryRequirements *>_ptr
+            self._ptr = <cyruntime.cudaArrayMemoryRequirements *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4464,36 +4602,41 @@ cdef class cudaArrayMemoryRequirements:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['alignment : ' + str(self.alignment)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['alignment : ' + str(self.alignment)]
+            except ValueError:
+                str_list += ['alignment : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, size_t size):
-        pass
         self._ptr[0].size = size
     @property
     def alignment(self):
         return self._ptr[0].alignment
     @alignment.setter
     def alignment(self, size_t alignment):
-        pass
         self._ptr[0].alignment = alignment
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if True or 'cudaPitchedPtr' in found_types}}
+{{if 'struct cudaPitchedPtr' in found_types}}
 
 cdef class cudaPitchedPtr:
     """
@@ -4520,7 +4663,7 @@ cdef class cudaPitchedPtr:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaPitchedPtr *>_ptr
+            self._ptr = <cyruntime.cudaPitchedPtr *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4530,44 +4673,52 @@ cdef class cudaPitchedPtr:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['ptr : ' + hex(self.ptr)]
-            str_list += ['pitch : ' + str(self.pitch)]
-            str_list += ['xsize : ' + str(self.xsize)]
-            str_list += ['ysize : ' + str(self.ysize)]
+            try:
+                str_list += ['ptr : ' + hex(self.ptr)]
+            except ValueError:
+                str_list += ['ptr : <ValueError>']
+            try:
+                str_list += ['pitch : ' + str(self.pitch)]
+            except ValueError:
+                str_list += ['pitch : <ValueError>']
+            try:
+                str_list += ['xsize : ' + str(self.xsize)]
+            except ValueError:
+                str_list += ['xsize : <ValueError>']
+            try:
+                str_list += ['ysize : ' + str(self.ysize)]
+            except ValueError:
+                str_list += ['ysize : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def ptr(self):
         return <void_ptr>self._ptr[0].ptr
     @ptr.setter
     def ptr(self, ptr):
-        _cptr = utils.HelperInputVoidPtr(ptr)
-        self._ptr[0].ptr = <void*><void_ptr>_cptr.cptr
+        _cyptr = utils.HelperInputVoidPtr(ptr)
+        self._ptr[0].ptr = <void*><void_ptr>_cyptr.cptr
     @property
     def pitch(self):
         return self._ptr[0].pitch
     @pitch.setter
     def pitch(self, size_t pitch):
-        pass
         self._ptr[0].pitch = pitch
     @property
     def xsize(self):
         return self._ptr[0].xsize
     @xsize.setter
     def xsize(self, size_t xsize):
-        pass
         self._ptr[0].xsize = xsize
     @property
     def ysize(self):
         return self._ptr[0].ysize
     @ysize.setter
     def ysize(self, size_t ysize):
-        pass
         self._ptr[0].ysize = ysize
 {{endif}}
-{{if 'cudaExtent' in found_types}}
+{{if 'struct cudaExtent' in found_types}}
 
 cdef class cudaExtent:
     """
@@ -4593,7 +4744,7 @@ cdef class cudaExtent:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExtent *>_ptr
+            self._ptr = <cyruntime.cudaExtent *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4603,36 +4754,41 @@ cdef class cudaExtent:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].height = height
     @property
     def depth(self):
         return self._ptr[0].depth
     @depth.setter
     def depth(self, size_t depth):
-        pass
         self._ptr[0].depth = depth
 {{endif}}
-{{if 'cudaPos' in found_types}}
+{{if 'struct cudaPos' in found_types}}
 
 cdef class cudaPos:
     """
@@ -4657,7 +4813,7 @@ cdef class cudaPos:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaPos *>_ptr
+            self._ptr = <cyruntime.cudaPos *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -4667,36 +4823,41 @@ cdef class cudaPos:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['x : ' + str(self.x)]
-            str_list += ['y : ' + str(self.y)]
-            str_list += ['z : ' + str(self.z)]
+            try:
+                str_list += ['x : ' + str(self.x)]
+            except ValueError:
+                str_list += ['x : <ValueError>']
+            try:
+                str_list += ['y : ' + str(self.y)]
+            except ValueError:
+                str_list += ['y : <ValueError>']
+            try:
+                str_list += ['z : ' + str(self.z)]
+            except ValueError:
+                str_list += ['z : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def x(self):
         return self._ptr[0].x
     @x.setter
     def x(self, size_t x):
-        pass
         self._ptr[0].x = x
     @property
     def y(self):
         return self._ptr[0].y
     @y.setter
     def y(self, size_t y):
-        pass
         self._ptr[0].y = y
     @property
     def z(self):
         return self._ptr[0].z
     @z.setter
     def z(self, size_t z):
-        pass
         self._ptr[0].z = z
 {{endif}}
-{{if 'cudaMemcpy3DParms' in found_types}}
+{{if 'struct cudaMemcpy3DParms' in found_types}}
 
 cdef class cudaMemcpy3DParms:
     """
@@ -4731,7 +4892,7 @@ cdef class cudaMemcpy3DParms:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemcpy3DParms *>_ptr
+            self._ptr = <cyruntime.cudaMemcpy3DParms *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._srcArray = cudaArray_t(_ptr=<void_ptr>&self._ptr[0].srcArray)
         self._srcPos = cudaPos(_ptr=<void_ptr>&self._ptr[0].srcPos)
@@ -4747,112 +4908,109 @@ cdef class cudaMemcpy3DParms:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['srcArray : ' + str(self.srcArray)]
-            str_list += ['srcPos :\n' + '\n'.join(['    ' + line for line in str(self.srcPos).splitlines()])]
-            str_list += ['srcPtr :\n' + '\n'.join(['    ' + line for line in str(self.srcPtr).splitlines()])]
-            str_list += ['dstArray : ' + str(self.dstArray)]
-            str_list += ['dstPos :\n' + '\n'.join(['    ' + line for line in str(self.dstPos).splitlines()])]
-            str_list += ['dstPtr :\n' + '\n'.join(['    ' + line for line in str(self.dstPtr).splitlines()])]
-            str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
-            str_list += ['kind : ' + str(self.kind)]
+            try:
+                str_list += ['srcArray : ' + str(self.srcArray)]
+            except ValueError:
+                str_list += ['srcArray : <ValueError>']
+            try:
+                str_list += ['srcPos :\n' + '\n'.join(['    ' + line for line in str(self.srcPos).splitlines()])]
+            except ValueError:
+                str_list += ['srcPos : <ValueError>']
+            try:
+                str_list += ['srcPtr :\n' + '\n'.join(['    ' + line for line in str(self.srcPtr).splitlines()])]
+            except ValueError:
+                str_list += ['srcPtr : <ValueError>']
+            try:
+                str_list += ['dstArray : ' + str(self.dstArray)]
+            except ValueError:
+                str_list += ['dstArray : <ValueError>']
+            try:
+                str_list += ['dstPos :\n' + '\n'.join(['    ' + line for line in str(self.dstPos).splitlines()])]
+            except ValueError:
+                str_list += ['dstPos : <ValueError>']
+            try:
+                str_list += ['dstPtr :\n' + '\n'.join(['    ' + line for line in str(self.dstPtr).splitlines()])]
+            except ValueError:
+                str_list += ['dstPtr : <ValueError>']
+            try:
+                str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
+            except ValueError:
+                str_list += ['extent : <ValueError>']
+            try:
+                str_list += ['kind : ' + str(self.kind)]
+            except ValueError:
+                str_list += ['kind : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def srcArray(self):
         return self._srcArray
     @srcArray.setter
     def srcArray(self, srcArray):
-        cdef ccudart.cudaArray_t csrcArray
+        cdef cyruntime.cudaArray_t cysrcArray
         if srcArray is None:
-            csrcArray = <ccudart.cudaArray_t><void_ptr>0
-        elif isinstance(srcArray, (cudaArray_t)):
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>0
+        elif isinstance(srcArray, (cudaArray_t,)):
             psrcArray = int(srcArray)
-            csrcArray = <ccudart.cudaArray_t><void_ptr>psrcArray
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>psrcArray
         else:
             psrcArray = int(cudaArray_t(srcArray))
-            csrcArray = <ccudart.cudaArray_t><void_ptr>psrcArray
-        self._srcArray._ptr[0] = csrcArray
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>psrcArray
+        self._srcArray._ptr[0] = cysrcArray
     @property
     def srcPos(self):
         return self._srcPos
     @srcPos.setter
     def srcPos(self, srcPos not None : cudaPos):
-        pass
-        for _attr in dir(srcPos):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._srcPos, _attr, getattr(srcPos, _attr))
+        string.memcpy(&self._ptr[0].srcPos, <cyruntime.cudaPos*><void_ptr>srcPos.getPtr(), sizeof(self._ptr[0].srcPos))
     @property
     def srcPtr(self):
         return self._srcPtr
     @srcPtr.setter
     def srcPtr(self, srcPtr not None : cudaPitchedPtr):
-        pass
-        for _attr in dir(srcPtr):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._srcPtr, _attr, getattr(srcPtr, _attr))
+        string.memcpy(&self._ptr[0].srcPtr, <cyruntime.cudaPitchedPtr*><void_ptr>srcPtr.getPtr(), sizeof(self._ptr[0].srcPtr))
     @property
     def dstArray(self):
         return self._dstArray
     @dstArray.setter
     def dstArray(self, dstArray):
-        cdef ccudart.cudaArray_t cdstArray
+        cdef cyruntime.cudaArray_t cydstArray
         if dstArray is None:
-            cdstArray = <ccudart.cudaArray_t><void_ptr>0
-        elif isinstance(dstArray, (cudaArray_t)):
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>0
+        elif isinstance(dstArray, (cudaArray_t,)):
             pdstArray = int(dstArray)
-            cdstArray = <ccudart.cudaArray_t><void_ptr>pdstArray
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>pdstArray
         else:
             pdstArray = int(cudaArray_t(dstArray))
-            cdstArray = <ccudart.cudaArray_t><void_ptr>pdstArray
-        self._dstArray._ptr[0] = cdstArray
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>pdstArray
+        self._dstArray._ptr[0] = cydstArray
     @property
     def dstPos(self):
         return self._dstPos
     @dstPos.setter
     def dstPos(self, dstPos not None : cudaPos):
-        pass
-        for _attr in dir(dstPos):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._dstPos, _attr, getattr(dstPos, _attr))
+        string.memcpy(&self._ptr[0].dstPos, <cyruntime.cudaPos*><void_ptr>dstPos.getPtr(), sizeof(self._ptr[0].dstPos))
     @property
     def dstPtr(self):
         return self._dstPtr
     @dstPtr.setter
     def dstPtr(self, dstPtr not None : cudaPitchedPtr):
-        pass
-        for _attr in dir(dstPtr):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._dstPtr, _attr, getattr(dstPtr, _attr))
+        string.memcpy(&self._ptr[0].dstPtr, <cyruntime.cudaPitchedPtr*><void_ptr>dstPtr.getPtr(), sizeof(self._ptr[0].dstPtr))
     @property
     def extent(self):
         return self._extent
     @extent.setter
     def extent(self, extent not None : cudaExtent):
-        pass
-        for _attr in dir(extent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._extent, _attr, getattr(extent, _attr))
+        string.memcpy(&self._ptr[0].extent, <cyruntime.cudaExtent*><void_ptr>extent.getPtr(), sizeof(self._ptr[0].extent))
     @property
     def kind(self):
         return cudaMemcpyKind(self._ptr[0].kind)
     @kind.setter
     def kind(self, kind not None : cudaMemcpyKind):
-        pass
         self._ptr[0].kind = kind.value
 {{endif}}
-{{if 'cudaMemcpy3DPeerParms' in found_types}}
+{{if 'struct cudaMemcpy3DPeerParms' in found_types}}
 
 cdef class cudaMemcpy3DPeerParms:
     """
@@ -4889,7 +5047,7 @@ cdef class cudaMemcpy3DPeerParms:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemcpy3DPeerParms *>_ptr
+            self._ptr = <cyruntime.cudaMemcpy3DPeerParms *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._srcArray = cudaArray_t(_ptr=<void_ptr>&self._ptr[0].srcArray)
         self._srcPos = cudaPos(_ptr=<void_ptr>&self._ptr[0].srcPos)
@@ -4905,120 +5063,119 @@ cdef class cudaMemcpy3DPeerParms:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['srcArray : ' + str(self.srcArray)]
-            str_list += ['srcPos :\n' + '\n'.join(['    ' + line for line in str(self.srcPos).splitlines()])]
-            str_list += ['srcPtr :\n' + '\n'.join(['    ' + line for line in str(self.srcPtr).splitlines()])]
-            str_list += ['srcDevice : ' + str(self.srcDevice)]
-            str_list += ['dstArray : ' + str(self.dstArray)]
-            str_list += ['dstPos :\n' + '\n'.join(['    ' + line for line in str(self.dstPos).splitlines()])]
-            str_list += ['dstPtr :\n' + '\n'.join(['    ' + line for line in str(self.dstPtr).splitlines()])]
-            str_list += ['dstDevice : ' + str(self.dstDevice)]
-            str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
+            try:
+                str_list += ['srcArray : ' + str(self.srcArray)]
+            except ValueError:
+                str_list += ['srcArray : <ValueError>']
+            try:
+                str_list += ['srcPos :\n' + '\n'.join(['    ' + line for line in str(self.srcPos).splitlines()])]
+            except ValueError:
+                str_list += ['srcPos : <ValueError>']
+            try:
+                str_list += ['srcPtr :\n' + '\n'.join(['    ' + line for line in str(self.srcPtr).splitlines()])]
+            except ValueError:
+                str_list += ['srcPtr : <ValueError>']
+            try:
+                str_list += ['srcDevice : ' + str(self.srcDevice)]
+            except ValueError:
+                str_list += ['srcDevice : <ValueError>']
+            try:
+                str_list += ['dstArray : ' + str(self.dstArray)]
+            except ValueError:
+                str_list += ['dstArray : <ValueError>']
+            try:
+                str_list += ['dstPos :\n' + '\n'.join(['    ' + line for line in str(self.dstPos).splitlines()])]
+            except ValueError:
+                str_list += ['dstPos : <ValueError>']
+            try:
+                str_list += ['dstPtr :\n' + '\n'.join(['    ' + line for line in str(self.dstPtr).splitlines()])]
+            except ValueError:
+                str_list += ['dstPtr : <ValueError>']
+            try:
+                str_list += ['dstDevice : ' + str(self.dstDevice)]
+            except ValueError:
+                str_list += ['dstDevice : <ValueError>']
+            try:
+                str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
+            except ValueError:
+                str_list += ['extent : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def srcArray(self):
         return self._srcArray
     @srcArray.setter
     def srcArray(self, srcArray):
-        cdef ccudart.cudaArray_t csrcArray
+        cdef cyruntime.cudaArray_t cysrcArray
         if srcArray is None:
-            csrcArray = <ccudart.cudaArray_t><void_ptr>0
-        elif isinstance(srcArray, (cudaArray_t)):
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>0
+        elif isinstance(srcArray, (cudaArray_t,)):
             psrcArray = int(srcArray)
-            csrcArray = <ccudart.cudaArray_t><void_ptr>psrcArray
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>psrcArray
         else:
             psrcArray = int(cudaArray_t(srcArray))
-            csrcArray = <ccudart.cudaArray_t><void_ptr>psrcArray
-        self._srcArray._ptr[0] = csrcArray
+            cysrcArray = <cyruntime.cudaArray_t><void_ptr>psrcArray
+        self._srcArray._ptr[0] = cysrcArray
     @property
     def srcPos(self):
         return self._srcPos
     @srcPos.setter
     def srcPos(self, srcPos not None : cudaPos):
-        pass
-        for _attr in dir(srcPos):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._srcPos, _attr, getattr(srcPos, _attr))
+        string.memcpy(&self._ptr[0].srcPos, <cyruntime.cudaPos*><void_ptr>srcPos.getPtr(), sizeof(self._ptr[0].srcPos))
     @property
     def srcPtr(self):
         return self._srcPtr
     @srcPtr.setter
     def srcPtr(self, srcPtr not None : cudaPitchedPtr):
-        pass
-        for _attr in dir(srcPtr):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._srcPtr, _attr, getattr(srcPtr, _attr))
+        string.memcpy(&self._ptr[0].srcPtr, <cyruntime.cudaPitchedPtr*><void_ptr>srcPtr.getPtr(), sizeof(self._ptr[0].srcPtr))
     @property
     def srcDevice(self):
         return self._ptr[0].srcDevice
     @srcDevice.setter
     def srcDevice(self, int srcDevice):
-        pass
         self._ptr[0].srcDevice = srcDevice
     @property
     def dstArray(self):
         return self._dstArray
     @dstArray.setter
     def dstArray(self, dstArray):
-        cdef ccudart.cudaArray_t cdstArray
+        cdef cyruntime.cudaArray_t cydstArray
         if dstArray is None:
-            cdstArray = <ccudart.cudaArray_t><void_ptr>0
-        elif isinstance(dstArray, (cudaArray_t)):
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>0
+        elif isinstance(dstArray, (cudaArray_t,)):
             pdstArray = int(dstArray)
-            cdstArray = <ccudart.cudaArray_t><void_ptr>pdstArray
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>pdstArray
         else:
             pdstArray = int(cudaArray_t(dstArray))
-            cdstArray = <ccudart.cudaArray_t><void_ptr>pdstArray
-        self._dstArray._ptr[0] = cdstArray
+            cydstArray = <cyruntime.cudaArray_t><void_ptr>pdstArray
+        self._dstArray._ptr[0] = cydstArray
     @property
     def dstPos(self):
         return self._dstPos
     @dstPos.setter
     def dstPos(self, dstPos not None : cudaPos):
-        pass
-        for _attr in dir(dstPos):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._dstPos, _attr, getattr(dstPos, _attr))
+        string.memcpy(&self._ptr[0].dstPos, <cyruntime.cudaPos*><void_ptr>dstPos.getPtr(), sizeof(self._ptr[0].dstPos))
     @property
     def dstPtr(self):
         return self._dstPtr
     @dstPtr.setter
     def dstPtr(self, dstPtr not None : cudaPitchedPtr):
-        pass
-        for _attr in dir(dstPtr):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._dstPtr, _attr, getattr(dstPtr, _attr))
+        string.memcpy(&self._ptr[0].dstPtr, <cyruntime.cudaPitchedPtr*><void_ptr>dstPtr.getPtr(), sizeof(self._ptr[0].dstPtr))
     @property
     def dstDevice(self):
         return self._ptr[0].dstDevice
     @dstDevice.setter
     def dstDevice(self, int dstDevice):
-        pass
         self._ptr[0].dstDevice = dstDevice
     @property
     def extent(self):
         return self._extent
     @extent.setter
     def extent(self, extent not None : cudaExtent):
-        pass
-        for _attr in dir(extent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._extent, _attr, getattr(extent, _attr))
+        string.memcpy(&self._ptr[0].extent, <cyruntime.cudaExtent*><void_ptr>extent.getPtr(), sizeof(self._ptr[0].extent))
 {{endif}}
-{{if 'cudaMemsetParams' in found_types}}
+{{if 'struct cudaMemsetParams' in found_types}}
 
 cdef class cudaMemsetParams:
     """
@@ -5049,7 +5206,7 @@ cdef class cudaMemsetParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemsetParams *>_ptr
+            self._ptr = <cyruntime.cudaMemsetParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5059,60 +5216,72 @@ cdef class cudaMemsetParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['dst : ' + hex(self.dst)]
-            str_list += ['pitch : ' + str(self.pitch)]
-            str_list += ['value : ' + str(self.value)]
-            str_list += ['elementSize : ' + str(self.elementSize)]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
+            try:
+                str_list += ['dst : ' + hex(self.dst)]
+            except ValueError:
+                str_list += ['dst : <ValueError>']
+            try:
+                str_list += ['pitch : ' + str(self.pitch)]
+            except ValueError:
+                str_list += ['pitch : <ValueError>']
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
+            try:
+                str_list += ['elementSize : ' + str(self.elementSize)]
+            except ValueError:
+                str_list += ['elementSize : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def dst(self):
         return <void_ptr>self._ptr[0].dst
     @dst.setter
     def dst(self, dst):
-        _cdst = utils.HelperInputVoidPtr(dst)
-        self._ptr[0].dst = <void*><void_ptr>_cdst.cptr
+        _cydst = utils.HelperInputVoidPtr(dst)
+        self._ptr[0].dst = <void*><void_ptr>_cydst.cptr
     @property
     def pitch(self):
         return self._ptr[0].pitch
     @pitch.setter
     def pitch(self, size_t pitch):
-        pass
         self._ptr[0].pitch = pitch
     @property
     def value(self):
         return self._ptr[0].value
     @value.setter
     def value(self, unsigned int value):
-        pass
         self._ptr[0].value = value
     @property
     def elementSize(self):
         return self._ptr[0].elementSize
     @elementSize.setter
     def elementSize(self, unsigned int elementSize):
-        pass
         self._ptr[0].elementSize = elementSize
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].height = height
 {{endif}}
-{{if 'cudaAccessPolicyWindow' in found_types}}
+{{if 'struct cudaAccessPolicyWindow' in found_types}}
 
 cdef class cudaAccessPolicyWindow:
     """
@@ -5152,7 +5321,7 @@ cdef class cudaAccessPolicyWindow:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaAccessPolicyWindow *>_ptr
+            self._ptr = <cyruntime.cudaAccessPolicyWindow *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5162,52 +5331,62 @@ cdef class cudaAccessPolicyWindow:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['base_ptr : ' + hex(self.base_ptr)]
-            str_list += ['num_bytes : ' + str(self.num_bytes)]
-            str_list += ['hitRatio : ' + str(self.hitRatio)]
-            str_list += ['hitProp : ' + str(self.hitProp)]
-            str_list += ['missProp : ' + str(self.missProp)]
+            try:
+                str_list += ['base_ptr : ' + hex(self.base_ptr)]
+            except ValueError:
+                str_list += ['base_ptr : <ValueError>']
+            try:
+                str_list += ['num_bytes : ' + str(self.num_bytes)]
+            except ValueError:
+                str_list += ['num_bytes : <ValueError>']
+            try:
+                str_list += ['hitRatio : ' + str(self.hitRatio)]
+            except ValueError:
+                str_list += ['hitRatio : <ValueError>']
+            try:
+                str_list += ['hitProp : ' + str(self.hitProp)]
+            except ValueError:
+                str_list += ['hitProp : <ValueError>']
+            try:
+                str_list += ['missProp : ' + str(self.missProp)]
+            except ValueError:
+                str_list += ['missProp : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def base_ptr(self):
         return <void_ptr>self._ptr[0].base_ptr
     @base_ptr.setter
     def base_ptr(self, base_ptr):
-        _cbase_ptr = utils.HelperInputVoidPtr(base_ptr)
-        self._ptr[0].base_ptr = <void*><void_ptr>_cbase_ptr.cptr
+        _cybase_ptr = utils.HelperInputVoidPtr(base_ptr)
+        self._ptr[0].base_ptr = <void*><void_ptr>_cybase_ptr.cptr
     @property
     def num_bytes(self):
         return self._ptr[0].num_bytes
     @num_bytes.setter
     def num_bytes(self, size_t num_bytes):
-        pass
         self._ptr[0].num_bytes = num_bytes
     @property
     def hitRatio(self):
         return self._ptr[0].hitRatio
     @hitRatio.setter
     def hitRatio(self, float hitRatio):
-        pass
         self._ptr[0].hitRatio = hitRatio
     @property
     def hitProp(self):
         return cudaAccessProperty(self._ptr[0].hitProp)
     @hitProp.setter
     def hitProp(self, hitProp not None : cudaAccessProperty):
-        pass
         self._ptr[0].hitProp = hitProp.value
     @property
     def missProp(self):
         return cudaAccessProperty(self._ptr[0].missProp)
     @missProp.setter
     def missProp(self, missProp not None : cudaAccessProperty):
-        pass
         self._ptr[0].missProp = missProp.value
 {{endif}}
-{{if 'cudaHostNodeParams' in found_types}}
+{{if 'struct cudaHostNodeParams' in found_types}}
 
 cdef class cudaHostNodeParams:
     """
@@ -5230,7 +5409,7 @@ cdef class cudaHostNodeParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaHostNodeParams *>_ptr
+            self._ptr = <cyruntime.cudaHostNodeParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._fn = cudaHostFn_t(_ptr=<void_ptr>&self._ptr[0].fn)
     def __dealloc__(self):
@@ -5240,40 +5419,44 @@ cdef class cudaHostNodeParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fn : ' + str(self.fn)]
-            str_list += ['userData : ' + hex(self.userData)]
+            try:
+                str_list += ['fn : ' + str(self.fn)]
+            except ValueError:
+                str_list += ['fn : <ValueError>']
+            try:
+                str_list += ['userData : ' + hex(self.userData)]
+            except ValueError:
+                str_list += ['userData : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fn(self):
         return self._fn
     @fn.setter
     def fn(self, fn):
-        cdef ccudart.cudaHostFn_t cfn
+        cdef cyruntime.cudaHostFn_t cyfn
         if fn is None:
-            cfn = <ccudart.cudaHostFn_t><void_ptr>0
+            cyfn = <cyruntime.cudaHostFn_t><void_ptr>0
         elif isinstance(fn, (cudaHostFn_t)):
             pfn = int(fn)
-            cfn = <ccudart.cudaHostFn_t><void_ptr>pfn
+            cyfn = <cyruntime.cudaHostFn_t><void_ptr>pfn
         else:
             pfn = int(cudaHostFn_t(fn))
-            cfn = <ccudart.cudaHostFn_t><void_ptr>pfn
-        self._fn._ptr[0] = cfn
+            cyfn = <cyruntime.cudaHostFn_t><void_ptr>pfn
+        self._fn._ptr[0] = cyfn
     @property
     def userData(self):
         return <void_ptr>self._ptr[0].userData
     @userData.setter
     def userData(self, userData):
-        _cuserData = utils.HelperInputVoidPtr(userData)
-        self._ptr[0].userData = <void*><void_ptr>_cuserData.cptr
+        _cyuserData = utils.HelperInputVoidPtr(userData)
+        self._ptr[0].userData = <void*><void_ptr>_cyuserData.cptr
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_array_s:
+cdef class anon_struct1:
     """
-
     Attributes
     ----------
     array : cudaArray_t
@@ -5286,40 +5469,44 @@ cdef class _cudaResourceDesc_res_res_array_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaResourceDesc *>_ptr
+        self._ptr = <cyruntime.cudaResourceDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._array = cudaArray_t(_ptr=<void_ptr>&self._ptr[0].res.array.array)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.array
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['array : ' + str(self.array)]
+            try:
+                str_list += ['array : ' + str(self.array)]
+            except ValueError:
+                str_list += ['array : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def array(self):
         return self._array
     @array.setter
     def array(self, array):
-        cdef ccudart.cudaArray_t carray
+        cdef cyruntime.cudaArray_t cyarray
         if array is None:
-            carray = <ccudart.cudaArray_t><void_ptr>0
-        elif isinstance(array, (cudaArray_t)):
+            cyarray = <cyruntime.cudaArray_t><void_ptr>0
+        elif isinstance(array, (cudaArray_t,)):
             parray = int(array)
-            carray = <ccudart.cudaArray_t><void_ptr>parray
+            cyarray = <cyruntime.cudaArray_t><void_ptr>parray
         else:
             parray = int(cudaArray_t(array))
-            carray = <ccudart.cudaArray_t><void_ptr>parray
-        self._array._ptr[0] = carray
+            cyarray = <cyruntime.cudaArray_t><void_ptr>parray
+        self._array._ptr[0] = cyarray
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_mipmap_s:
+cdef class anon_struct2:
     """
-
     Attributes
     ----------
     mipmap : cudaMipmappedArray_t
@@ -5332,43 +5519,47 @@ cdef class _cudaResourceDesc_res_res_mipmap_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaResourceDesc *>_ptr
+        self._ptr = <cyruntime.cudaResourceDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._mipmap = cudaMipmappedArray_t(_ptr=<void_ptr>&self._ptr[0].res.mipmap.mipmap)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.mipmap
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['mipmap : ' + str(self.mipmap)]
+            try:
+                str_list += ['mipmap : ' + str(self.mipmap)]
+            except ValueError:
+                str_list += ['mipmap : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def mipmap(self):
         return self._mipmap
     @mipmap.setter
     def mipmap(self, mipmap):
-        cdef ccudart.cudaMipmappedArray_t cmipmap
+        cdef cyruntime.cudaMipmappedArray_t cymipmap
         if mipmap is None:
-            cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>0
-        elif isinstance(mipmap, (cudaMipmappedArray_t)):
+            cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>0
+        elif isinstance(mipmap, (cudaMipmappedArray_t,)):
             pmipmap = int(mipmap)
-            cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
+            cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
         else:
             pmipmap = int(cudaMipmappedArray_t(mipmap))
-            cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
-        self._mipmap._ptr[0] = cmipmap
+            cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
+        self._mipmap._ptr[0] = cymipmap
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_linear_s:
+cdef class anon_struct3:
     """
-
     Attributes
     ----------
-    devPtr : void
+    devPtr : Any
 
     desc : cudaChannelFormatDesc
 
@@ -5382,55 +5573,59 @@ cdef class _cudaResourceDesc_res_res_linear_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaResourceDesc *>_ptr
+        self._ptr = <cyruntime.cudaResourceDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._desc = cudaChannelFormatDesc(_ptr=<void_ptr>&self._ptr[0].res.linear.desc)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.linear
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['devPtr : ' + hex(self.devPtr)]
-            str_list += ['desc :\n' + '\n'.join(['    ' + line for line in str(self.desc).splitlines()])]
-            str_list += ['sizeInBytes : ' + str(self.sizeInBytes)]
+            try:
+                str_list += ['devPtr : ' + hex(self.devPtr)]
+            except ValueError:
+                str_list += ['devPtr : <ValueError>']
+            try:
+                str_list += ['desc :\n' + '\n'.join(['    ' + line for line in str(self.desc).splitlines()])]
+            except ValueError:
+                str_list += ['desc : <ValueError>']
+            try:
+                str_list += ['sizeInBytes : ' + str(self.sizeInBytes)]
+            except ValueError:
+                str_list += ['sizeInBytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def devPtr(self):
         return <void_ptr>self._ptr[0].res.linear.devPtr
     @devPtr.setter
     def devPtr(self, devPtr):
-        _cdevPtr = utils.HelperInputVoidPtr(devPtr)
-        self._ptr[0].res.linear.devPtr = <void*><void_ptr>_cdevPtr.cptr
+        _cydevPtr = utils.HelperInputVoidPtr(devPtr)
+        self._ptr[0].res.linear.devPtr = <void*><void_ptr>_cydevPtr.cptr
     @property
     def desc(self):
         return self._desc
     @desc.setter
     def desc(self, desc not None : cudaChannelFormatDesc):
-        pass
-        for _attr in dir(desc):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._desc, _attr, getattr(desc, _attr))
+        string.memcpy(&self._ptr[0].res.linear.desc, <cyruntime.cudaChannelFormatDesc*><void_ptr>desc.getPtr(), sizeof(self._ptr[0].res.linear.desc))
     @property
     def sizeInBytes(self):
         return self._ptr[0].res.linear.sizeInBytes
     @sizeInBytes.setter
     def sizeInBytes(self, size_t sizeInBytes):
-        pass
         self._ptr[0].res.linear.sizeInBytes = sizeInBytes
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_res_pitch2D_s:
+cdef class anon_struct4:
     """
-
     Attributes
     ----------
-    devPtr : void
+    devPtr : Any
 
     desc : cudaChannelFormatDesc
 
@@ -5448,77 +5643,85 @@ cdef class _cudaResourceDesc_res_res_pitch2D_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaResourceDesc *>_ptr
+        self._ptr = <cyruntime.cudaResourceDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._desc = cudaChannelFormatDesc(_ptr=<void_ptr>&self._ptr[0].res.pitch2D.desc)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res.pitch2D
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['devPtr : ' + hex(self.devPtr)]
-            str_list += ['desc :\n' + '\n'.join(['    ' + line for line in str(self.desc).splitlines()])]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['pitchInBytes : ' + str(self.pitchInBytes)]
+            try:
+                str_list += ['devPtr : ' + hex(self.devPtr)]
+            except ValueError:
+                str_list += ['devPtr : <ValueError>']
+            try:
+                str_list += ['desc :\n' + '\n'.join(['    ' + line for line in str(self.desc).splitlines()])]
+            except ValueError:
+                str_list += ['desc : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['pitchInBytes : ' + str(self.pitchInBytes)]
+            except ValueError:
+                str_list += ['pitchInBytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def devPtr(self):
         return <void_ptr>self._ptr[0].res.pitch2D.devPtr
     @devPtr.setter
     def devPtr(self, devPtr):
-        _cdevPtr = utils.HelperInputVoidPtr(devPtr)
-        self._ptr[0].res.pitch2D.devPtr = <void*><void_ptr>_cdevPtr.cptr
+        _cydevPtr = utils.HelperInputVoidPtr(devPtr)
+        self._ptr[0].res.pitch2D.devPtr = <void*><void_ptr>_cydevPtr.cptr
     @property
     def desc(self):
         return self._desc
     @desc.setter
     def desc(self, desc not None : cudaChannelFormatDesc):
-        pass
-        for _attr in dir(desc):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._desc, _attr, getattr(desc, _attr))
+        string.memcpy(&self._ptr[0].res.pitch2D.desc, <cyruntime.cudaChannelFormatDesc*><void_ptr>desc.getPtr(), sizeof(self._ptr[0].res.pitch2D.desc))
     @property
     def width(self):
         return self._ptr[0].res.pitch2D.width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].res.pitch2D.width = width
     @property
     def height(self):
         return self._ptr[0].res.pitch2D.height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].res.pitch2D.height = height
     @property
     def pitchInBytes(self):
         return self._ptr[0].res.pitch2D.pitchInBytes
     @pitchInBytes.setter
     def pitchInBytes(self, size_t pitchInBytes):
-        pass
         self._ptr[0].res.pitch2D.pitchInBytes = pitchInBytes
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
-cdef class _cudaResourceDesc_res_u:
+cdef class anon_union0:
     """
-
     Attributes
     ----------
-    array : _cudaResourceDesc_res_res_array_s
+    array : anon_struct1
 
-    mipmap : _cudaResourceDesc_res_res_mipmap_s
+    mipmap : anon_struct2
 
-    linear : _cudaResourceDesc_res_res_linear_s
+    linear : anon_struct3
 
-    pitch2D : _cudaResourceDesc_res_res_pitch2D_s
+    pitch2D : anon_struct4
 
 
     Methods
@@ -5528,71 +5731,65 @@ cdef class _cudaResourceDesc_res_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaResourceDesc *>_ptr
+        self._ptr = <cyruntime.cudaResourceDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._array = _cudaResourceDesc_res_res_array_s(_ptr=<void_ptr>self._ptr)
-        self._mipmap = _cudaResourceDesc_res_res_mipmap_s(_ptr=<void_ptr>self._ptr)
-        self._linear = _cudaResourceDesc_res_res_linear_s(_ptr=<void_ptr>self._ptr)
-        self._pitch2D = _cudaResourceDesc_res_res_pitch2D_s(_ptr=<void_ptr>self._ptr)
+        self._array = anon_struct1(_ptr=<void_ptr>self._ptr)
+        self._mipmap = anon_struct2(_ptr=<void_ptr>self._ptr)
+        self._linear = anon_struct3(_ptr=<void_ptr>self._ptr)
+        self._pitch2D = anon_struct4(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].res
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['array :\n' + '\n'.join(['    ' + line for line in str(self.array).splitlines()])]
-            str_list += ['mipmap :\n' + '\n'.join(['    ' + line for line in str(self.mipmap).splitlines()])]
-            str_list += ['linear :\n' + '\n'.join(['    ' + line for line in str(self.linear).splitlines()])]
-            str_list += ['pitch2D :\n' + '\n'.join(['    ' + line for line in str(self.pitch2D).splitlines()])]
+            try:
+                str_list += ['array :\n' + '\n'.join(['    ' + line for line in str(self.array).splitlines()])]
+            except ValueError:
+                str_list += ['array : <ValueError>']
+            try:
+                str_list += ['mipmap :\n' + '\n'.join(['    ' + line for line in str(self.mipmap).splitlines()])]
+            except ValueError:
+                str_list += ['mipmap : <ValueError>']
+            try:
+                str_list += ['linear :\n' + '\n'.join(['    ' + line for line in str(self.linear).splitlines()])]
+            except ValueError:
+                str_list += ['linear : <ValueError>']
+            try:
+                str_list += ['pitch2D :\n' + '\n'.join(['    ' + line for line in str(self.pitch2D).splitlines()])]
+            except ValueError:
+                str_list += ['pitch2D : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def array(self):
         return self._array
     @array.setter
-    def array(self, array not None : _cudaResourceDesc_res_res_array_s):
-        pass
-        for _attr in dir(array):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._array, _attr, getattr(array, _attr))
+    def array(self, array not None : anon_struct1):
+        string.memcpy(&self._ptr[0].res.array, <cyruntime.anon_struct1*><void_ptr>array.getPtr(), sizeof(self._ptr[0].res.array))
     @property
     def mipmap(self):
         return self._mipmap
     @mipmap.setter
-    def mipmap(self, mipmap not None : _cudaResourceDesc_res_res_mipmap_s):
-        pass
-        for _attr in dir(mipmap):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._mipmap, _attr, getattr(mipmap, _attr))
+    def mipmap(self, mipmap not None : anon_struct2):
+        string.memcpy(&self._ptr[0].res.mipmap, <cyruntime.anon_struct2*><void_ptr>mipmap.getPtr(), sizeof(self._ptr[0].res.mipmap))
     @property
     def linear(self):
         return self._linear
     @linear.setter
-    def linear(self, linear not None : _cudaResourceDesc_res_res_linear_s):
-        pass
-        for _attr in dir(linear):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._linear, _attr, getattr(linear, _attr))
+    def linear(self, linear not None : anon_struct3):
+        string.memcpy(&self._ptr[0].res.linear, <cyruntime.anon_struct3*><void_ptr>linear.getPtr(), sizeof(self._ptr[0].res.linear))
     @property
     def pitch2D(self):
         return self._pitch2D
     @pitch2D.setter
-    def pitch2D(self, pitch2D not None : _cudaResourceDesc_res_res_pitch2D_s):
-        pass
-        for _attr in dir(pitch2D):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._pitch2D, _attr, getattr(pitch2D, _attr))
+    def pitch2D(self, pitch2D not None : anon_struct4):
+        string.memcpy(&self._ptr[0].res.pitch2D, <cyruntime.anon_struct4*><void_ptr>pitch2D.getPtr(), sizeof(self._ptr[0].res.pitch2D))
 {{endif}}
-{{if 'cudaResourceDesc' in found_types}}
+{{if 'struct cudaResourceDesc' in found_types}}
 
 cdef class cudaResourceDesc:
     """
@@ -5602,7 +5799,7 @@ cdef class cudaResourceDesc:
     ----------
     resType : cudaResourceType
         Resource type
-    res : _cudaResourceDesc_res_u
+    res : anon_union0
 
 
     Methods
@@ -5613,44 +5810,45 @@ cdef class cudaResourceDesc:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cyruntime.cudaResourceDesc *>calloc(1, sizeof(cyruntime.cudaResourceDesc))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccudart.cudaResourceDesc *>_ptr
+            self._ptr = <cyruntime.cudaResourceDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._res = _cudaResourceDesc_res_u(_ptr=<void_ptr>self._ptr)
+        self._res = anon_union0(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['resType : ' + str(self.resType)]
-            str_list += ['res :\n' + '\n'.join(['    ' + line for line in str(self.res).splitlines()])]
+            try:
+                str_list += ['resType : ' + str(self.resType)]
+            except ValueError:
+                str_list += ['resType : <ValueError>']
+            try:
+                str_list += ['res :\n' + '\n'.join(['    ' + line for line in str(self.res).splitlines()])]
+            except ValueError:
+                str_list += ['res : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def resType(self):
         return cudaResourceType(self._ptr[0].resType)
     @resType.setter
     def resType(self, resType not None : cudaResourceType):
-        pass
         self._ptr[0].resType = resType.value
     @property
     def res(self):
         return self._res
     @res.setter
-    def res(self, res not None : _cudaResourceDesc_res_u):
-        pass
-        for _attr in dir(res):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._res, _attr, getattr(res, _attr))
+    def res(self, res not None : anon_union0):
+        string.memcpy(&self._ptr[0].res, <cyruntime.anon_union0*><void_ptr>res.getPtr(), sizeof(self._ptr[0].res))
 {{endif}}
-{{if 'cudaResourceViewDesc' in found_types}}
+{{if 'struct cudaResourceViewDesc' in found_types}}
 
 cdef class cudaResourceViewDesc:
     """
@@ -5685,7 +5883,7 @@ cdef class cudaResourceViewDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaResourceViewDesc *>_ptr
+            self._ptr = <cyruntime.cudaResourceViewDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5695,76 +5893,91 @@ cdef class cudaResourceViewDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['format : ' + str(self.format)]
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
-            str_list += ['firstMipmapLevel : ' + str(self.firstMipmapLevel)]
-            str_list += ['lastMipmapLevel : ' + str(self.lastMipmapLevel)]
-            str_list += ['firstLayer : ' + str(self.firstLayer)]
-            str_list += ['lastLayer : ' + str(self.lastLayer)]
+            try:
+                str_list += ['format : ' + str(self.format)]
+            except ValueError:
+                str_list += ['format : <ValueError>']
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
+            try:
+                str_list += ['firstMipmapLevel : ' + str(self.firstMipmapLevel)]
+            except ValueError:
+                str_list += ['firstMipmapLevel : <ValueError>']
+            try:
+                str_list += ['lastMipmapLevel : ' + str(self.lastMipmapLevel)]
+            except ValueError:
+                str_list += ['lastMipmapLevel : <ValueError>']
+            try:
+                str_list += ['firstLayer : ' + str(self.firstLayer)]
+            except ValueError:
+                str_list += ['firstLayer : <ValueError>']
+            try:
+                str_list += ['lastLayer : ' + str(self.lastLayer)]
+            except ValueError:
+                str_list += ['lastLayer : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def format(self):
         return cudaResourceViewFormat(self._ptr[0].format)
     @format.setter
     def format(self, format not None : cudaResourceViewFormat):
-        pass
         self._ptr[0].format = format.value
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, size_t width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, size_t height):
-        pass
         self._ptr[0].height = height
     @property
     def depth(self):
         return self._ptr[0].depth
     @depth.setter
     def depth(self, size_t depth):
-        pass
         self._ptr[0].depth = depth
     @property
     def firstMipmapLevel(self):
         return self._ptr[0].firstMipmapLevel
     @firstMipmapLevel.setter
     def firstMipmapLevel(self, unsigned int firstMipmapLevel):
-        pass
         self._ptr[0].firstMipmapLevel = firstMipmapLevel
     @property
     def lastMipmapLevel(self):
         return self._ptr[0].lastMipmapLevel
     @lastMipmapLevel.setter
     def lastMipmapLevel(self, unsigned int lastMipmapLevel):
-        pass
         self._ptr[0].lastMipmapLevel = lastMipmapLevel
     @property
     def firstLayer(self):
         return self._ptr[0].firstLayer
     @firstLayer.setter
     def firstLayer(self, unsigned int firstLayer):
-        pass
         self._ptr[0].firstLayer = firstLayer
     @property
     def lastLayer(self):
         return self._ptr[0].lastLayer
     @lastLayer.setter
     def lastLayer(self, unsigned int lastLayer):
-        pass
         self._ptr[0].lastLayer = lastLayer
 {{endif}}
-{{if 'cudaPointerAttributes' in found_types}}
+{{if 'struct cudaPointerAttributes' in found_types}}
 
 cdef class cudaPointerAttributes:
     """
@@ -5802,7 +6015,7 @@ cdef class cudaPointerAttributes:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaPointerAttributes *>_ptr
+            self._ptr = <cyruntime.cudaPointerAttributes *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5812,42 +6025,51 @@ cdef class cudaPointerAttributes:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['device : ' + str(self.device)]
-            str_list += ['devicePointer : ' + hex(self.devicePointer)]
-            str_list += ['hostPointer : ' + hex(self.hostPointer)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['device : ' + str(self.device)]
+            except ValueError:
+                str_list += ['device : <ValueError>']
+            try:
+                str_list += ['devicePointer : ' + hex(self.devicePointer)]
+            except ValueError:
+                str_list += ['devicePointer : <ValueError>']
+            try:
+                str_list += ['hostPointer : ' + hex(self.hostPointer)]
+            except ValueError:
+                str_list += ['hostPointer : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return cudaMemoryType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : cudaMemoryType):
-        pass
         self._ptr[0].type = type.value
     @property
     def device(self):
         return self._ptr[0].device
     @device.setter
     def device(self, int device):
-        pass
         self._ptr[0].device = device
     @property
     def devicePointer(self):
         return <void_ptr>self._ptr[0].devicePointer
     @devicePointer.setter
     def devicePointer(self, devicePointer):
-        _cdevicePointer = utils.HelperInputVoidPtr(devicePointer)
-        self._ptr[0].devicePointer = <void*><void_ptr>_cdevicePointer.cptr
+        _cydevicePointer = utils.HelperInputVoidPtr(devicePointer)
+        self._ptr[0].devicePointer = <void*><void_ptr>_cydevicePointer.cptr
     @property
     def hostPointer(self):
         return <void_ptr>self._ptr[0].hostPointer
     @hostPointer.setter
     def hostPointer(self, hostPointer):
-        _chostPointer = utils.HelperInputVoidPtr(hostPointer)
-        self._ptr[0].hostPointer = <void*><void_ptr>_chostPointer.cptr
+        _cyhostPointer = utils.HelperInputVoidPtr(hostPointer)
+        self._ptr[0].hostPointer = <void*><void_ptr>_cyhostPointer.cptr
 {{endif}}
 {{if 'struct cudaFuncAttributes' in found_types}}
 
@@ -5907,7 +6129,7 @@ cdef class cudaFuncAttributes:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaFuncAttributes *>_ptr
+            self._ptr = <cyruntime.cudaFuncAttributes *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -5917,101 +6139,111 @@ cdef class cudaFuncAttributes:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            {{if 'sharedSizeBytes' in found_structs['cudaFuncAttributes']['members']}}str_list += ['sharedSizeBytes : ' + str(self.sharedSizeBytes)]{{endif}}
-            {{if 'constSizeBytes' in found_structs['cudaFuncAttributes']['members']}}str_list += ['constSizeBytes : ' + str(self.constSizeBytes)]{{endif}}
-            {{if 'localSizeBytes' in found_structs['cudaFuncAttributes']['members']}}str_list += ['localSizeBytes : ' + str(self.localSizeBytes)]{{endif}}
-            {{if 'maxThreadsPerBlock' in found_structs['cudaFuncAttributes']['members']}}str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]{{endif}}
-            {{if 'numRegs' in found_structs['cudaFuncAttributes']['members']}}str_list += ['numRegs : ' + str(self.numRegs)]{{endif}}
-            {{if 'ptxVersion' in found_structs['cudaFuncAttributes']['members']}}str_list += ['ptxVersion : ' + str(self.ptxVersion)]{{endif}}
-            {{if 'binaryVersion' in found_structs['cudaFuncAttributes']['members']}}str_list += ['binaryVersion : ' + str(self.binaryVersion)]{{endif}}
-            {{if 'cacheModeCA' in found_structs['cudaFuncAttributes']['members']}}str_list += ['cacheModeCA : ' + str(self.cacheModeCA)]{{endif}}
-            {{if 'maxDynamicSharedSizeBytes' in found_structs['cudaFuncAttributes']['members']}}str_list += ['maxDynamicSharedSizeBytes : ' + str(self.maxDynamicSharedSizeBytes)]{{endif}}
-            {{if 'preferredShmemCarveout' in found_structs['cudaFuncAttributes']['members']}}str_list += ['preferredShmemCarveout : ' + str(self.preferredShmemCarveout)]{{endif}}
+            try:
+                str_list += ['sharedSizeBytes : ' + str(self.sharedSizeBytes)]
+            except ValueError:
+                str_list += ['sharedSizeBytes : <ValueError>']
+            try:
+                str_list += ['constSizeBytes : ' + str(self.constSizeBytes)]
+            except ValueError:
+                str_list += ['constSizeBytes : <ValueError>']
+            try:
+                str_list += ['localSizeBytes : ' + str(self.localSizeBytes)]
+            except ValueError:
+                str_list += ['localSizeBytes : <ValueError>']
+            try:
+                str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]
+            except ValueError:
+                str_list += ['maxThreadsPerBlock : <ValueError>']
+            try:
+                str_list += ['numRegs : ' + str(self.numRegs)]
+            except ValueError:
+                str_list += ['numRegs : <ValueError>']
+            try:
+                str_list += ['ptxVersion : ' + str(self.ptxVersion)]
+            except ValueError:
+                str_list += ['ptxVersion : <ValueError>']
+            try:
+                str_list += ['binaryVersion : ' + str(self.binaryVersion)]
+            except ValueError:
+                str_list += ['binaryVersion : <ValueError>']
+            try:
+                str_list += ['cacheModeCA : ' + str(self.cacheModeCA)]
+            except ValueError:
+                str_list += ['cacheModeCA : <ValueError>']
+            try:
+                str_list += ['maxDynamicSharedSizeBytes : ' + str(self.maxDynamicSharedSizeBytes)]
+            except ValueError:
+                str_list += ['maxDynamicSharedSizeBytes : <ValueError>']
+            try:
+                str_list += ['preferredShmemCarveout : ' + str(self.preferredShmemCarveout)]
+            except ValueError:
+                str_list += ['preferredShmemCarveout : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-    {{if 'sharedSizeBytes' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def sharedSizeBytes(self):
         return self._ptr[0].sharedSizeBytes
     @sharedSizeBytes.setter
     def sharedSizeBytes(self, size_t sharedSizeBytes):
         self._ptr[0].sharedSizeBytes = sharedSizeBytes
-    {{endif}}
-    {{if 'constSizeBytes' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def constSizeBytes(self):
         return self._ptr[0].constSizeBytes
     @constSizeBytes.setter
     def constSizeBytes(self, size_t constSizeBytes):
         self._ptr[0].constSizeBytes = constSizeBytes
-    {{endif}}
-    {{if 'localSizeBytes' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def localSizeBytes(self):
         return self._ptr[0].localSizeBytes
     @localSizeBytes.setter
     def localSizeBytes(self, size_t localSizeBytes):
         self._ptr[0].localSizeBytes = localSizeBytes
-    {{endif}}
-    {{if 'maxThreadsPerBlock' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def maxThreadsPerBlock(self):
         return self._ptr[0].maxThreadsPerBlock
     @maxThreadsPerBlock.setter
     def maxThreadsPerBlock(self, int maxThreadsPerBlock):
         self._ptr[0].maxThreadsPerBlock = maxThreadsPerBlock
-    {{endif}}
-    {{if 'numRegs' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def numRegs(self):
         return self._ptr[0].numRegs
     @numRegs.setter
     def numRegs(self, int numRegs):
         self._ptr[0].numRegs = numRegs
-    {{endif}}
-    {{if 'ptxVersion' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def ptxVersion(self):
         return self._ptr[0].ptxVersion
     @ptxVersion.setter
     def ptxVersion(self, int ptxVersion):
         self._ptr[0].ptxVersion = ptxVersion
-    {{endif}}
-    {{if 'binaryVersion' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def binaryVersion(self):
         return self._ptr[0].binaryVersion
     @binaryVersion.setter
     def binaryVersion(self, int binaryVersion):
         self._ptr[0].binaryVersion = binaryVersion
-    {{endif}}
-    {{if 'cacheModeCA' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def cacheModeCA(self):
         return self._ptr[0].cacheModeCA
     @cacheModeCA.setter
     def cacheModeCA(self, int cacheModeCA):
         self._ptr[0].cacheModeCA = cacheModeCA
-    {{endif}}
-    {{if 'maxDynamicSharedSizeBytes' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def maxDynamicSharedSizeBytes(self):
         return self._ptr[0].maxDynamicSharedSizeBytes
     @maxDynamicSharedSizeBytes.setter
     def maxDynamicSharedSizeBytes(self, int maxDynamicSharedSizeBytes):
         self._ptr[0].maxDynamicSharedSizeBytes = maxDynamicSharedSizeBytes
-    {{endif}}
-    {{if 'preferredShmemCarveout' in found_structs['cudaFuncAttributes']['members']}}
     @property
     def preferredShmemCarveout(self):
         return self._ptr[0].preferredShmemCarveout
     @preferredShmemCarveout.setter
     def preferredShmemCarveout(self, int preferredShmemCarveout):
         self._ptr[0].preferredShmemCarveout = preferredShmemCarveout
-    {{endif}}
 {{endif}}
-{{if 'cudaMemLocation' in found_types}}
+{{if 'struct cudaMemLocation' in found_types}}
 
 cdef class cudaMemLocation:
     """
@@ -6035,7 +6267,7 @@ cdef class cudaMemLocation:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemLocation *>_ptr
+            self._ptr = <cyruntime.cudaMemLocation *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -6045,28 +6277,31 @@ cdef class cudaMemLocation:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['id : ' + str(self.id)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['id : ' + str(self.id)]
+            except ValueError:
+                str_list += ['id : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return cudaMemLocationType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : cudaMemLocationType):
-        pass
         self._ptr[0].type = type.value
     @property
     def id(self):
         return self._ptr[0].id
     @id.setter
     def id(self, int id):
-        pass
         self._ptr[0].id = id
 {{endif}}
-{{if 'cudaMemAccessDesc' in found_types}}
+{{if 'struct cudaMemAccessDesc' in found_types}}
 
 cdef class cudaMemAccessDesc:
     """
@@ -6089,7 +6324,7 @@ cdef class cudaMemAccessDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemAccessDesc *>_ptr
+            self._ptr = <cyruntime.cudaMemAccessDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._location = cudaMemLocation(_ptr=<void_ptr>&self._ptr[0].location)
     def __dealloc__(self):
@@ -6099,32 +6334,31 @@ cdef class cudaMemAccessDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
+            except ValueError:
+                str_list += ['location : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def location(self):
         return self._location
     @location.setter
     def location(self, location not None : cudaMemLocation):
-        pass
-        for _attr in dir(location):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._location, _attr, getattr(location, _attr))
+        string.memcpy(&self._ptr[0].location, <cyruntime.cudaMemLocation*><void_ptr>location.getPtr(), sizeof(self._ptr[0].location))
     @property
     def flags(self):
         return cudaMemAccessFlags(self._ptr[0].flags)
     @flags.setter
     def flags(self, flags not None : cudaMemAccessFlags):
-        pass
         self._ptr[0].flags = flags.value
 {{endif}}
-{{if 'cudaMemPoolProps' in found_types}}
+{{if 'struct cudaMemPoolProps' in found_types}}
 
 cdef class cudaMemPoolProps:
     """
@@ -6158,7 +6392,7 @@ cdef class cudaMemPoolProps:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemPoolProps *>_ptr
+            self._ptr = <cyruntime.cudaMemPoolProps *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._location = cudaMemLocation(_ptr=<void_ptr>&self._ptr[0].location)
     def __dealloc__(self):
@@ -6168,47 +6402,54 @@ cdef class cudaMemPoolProps:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['allocType : ' + str(self.allocType)]
-            str_list += ['handleTypes : ' + str(self.handleTypes)]
-            str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
-            str_list += ['win32SecurityAttributes : ' + hex(self.win32SecurityAttributes)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['allocType : ' + str(self.allocType)]
+            except ValueError:
+                str_list += ['allocType : <ValueError>']
+            try:
+                str_list += ['handleTypes : ' + str(self.handleTypes)]
+            except ValueError:
+                str_list += ['handleTypes : <ValueError>']
+            try:
+                str_list += ['location :\n' + '\n'.join(['    ' + line for line in str(self.location).splitlines()])]
+            except ValueError:
+                str_list += ['location : <ValueError>']
+            try:
+                str_list += ['win32SecurityAttributes : ' + hex(self.win32SecurityAttributes)]
+            except ValueError:
+                str_list += ['win32SecurityAttributes : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def allocType(self):
         return cudaMemAllocationType(self._ptr[0].allocType)
     @allocType.setter
     def allocType(self, allocType not None : cudaMemAllocationType):
-        pass
         self._ptr[0].allocType = allocType.value
     @property
     def handleTypes(self):
         return cudaMemAllocationHandleType(self._ptr[0].handleTypes)
     @handleTypes.setter
     def handleTypes(self, handleTypes not None : cudaMemAllocationHandleType):
-        pass
         self._ptr[0].handleTypes = handleTypes.value
     @property
     def location(self):
         return self._location
     @location.setter
     def location(self, location not None : cudaMemLocation):
-        pass
-        for _attr in dir(location):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._location, _attr, getattr(location, _attr))
+        string.memcpy(&self._ptr[0].location, <cyruntime.cudaMemLocation*><void_ptr>location.getPtr(), sizeof(self._ptr[0].location))
     @property
     def win32SecurityAttributes(self):
         return <void_ptr>self._ptr[0].win32SecurityAttributes
     @win32SecurityAttributes.setter
     def win32SecurityAttributes(self, win32SecurityAttributes):
-        _cwin32SecurityAttributes = utils.HelperInputVoidPtr(win32SecurityAttributes)
-        self._ptr[0].win32SecurityAttributes = <void*><void_ptr>_cwin32SecurityAttributes.cptr
+        _cywin32SecurityAttributes = utils.HelperInputVoidPtr(win32SecurityAttributes)
+        self._ptr[0].win32SecurityAttributes = <void*><void_ptr>_cywin32SecurityAttributes.cptr
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(<char*>self._ptr[0].reserved, 64)
@@ -6219,7 +6460,7 @@ cdef class cudaMemPoolProps:
         for i, b in enumerate(reserved):
             self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'cudaMemPoolPtrExportData' in found_types}}
+{{if 'struct cudaMemPoolPtrExportData' in found_types}}
 
 cdef class cudaMemPoolPtrExportData:
     """
@@ -6240,7 +6481,7 @@ cdef class cudaMemPoolPtrExportData:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemPoolPtrExportData *>_ptr
+            self._ptr = <cyruntime.cudaMemPoolPtrExportData *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -6250,11 +6491,13 @@ cdef class cudaMemPoolPtrExportData:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(<char*>self._ptr[0].reserved, 64)
@@ -6265,7 +6508,7 @@ cdef class cudaMemPoolPtrExportData:
         for i, b in enumerate(reserved):
             self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'cudaMemAllocNodeParams' in found_types}}
+{{if 'struct cudaMemAllocNodeParams' in found_types}}
 
 cdef class cudaMemAllocNodeParams:
     """
@@ -6298,7 +6541,7 @@ cdef class cudaMemAllocNodeParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaMemAllocNodeParams *>_ptr
+            self._ptr = <cyruntime.cudaMemAllocNodeParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._poolProps = cudaMemPoolProps(_ptr=<void_ptr>&self._ptr[0].poolProps)
     def __dealloc__(self):
@@ -6309,29 +6552,38 @@ cdef class cudaMemAllocNodeParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['poolProps :\n' + '\n'.join(['    ' + line for line in str(self.poolProps).splitlines()])]
-            str_list += ['accessDescs : ' + str(self.accessDescs)]
-            str_list += ['accessDescCount : ' + str(self.accessDescCount)]
-            str_list += ['bytesize : ' + str(self.bytesize)]
-            str_list += ['dptr : ' + hex(self.dptr)]
+            try:
+                str_list += ['poolProps :\n' + '\n'.join(['    ' + line for line in str(self.poolProps).splitlines()])]
+            except ValueError:
+                str_list += ['poolProps : <ValueError>']
+            try:
+                str_list += ['accessDescs : ' + str(self.accessDescs)]
+            except ValueError:
+                str_list += ['accessDescs : <ValueError>']
+            try:
+                str_list += ['accessDescCount : ' + str(self.accessDescCount)]
+            except ValueError:
+                str_list += ['accessDescCount : <ValueError>']
+            try:
+                str_list += ['bytesize : ' + str(self.bytesize)]
+            except ValueError:
+                str_list += ['bytesize : <ValueError>']
+            try:
+                str_list += ['dptr : ' + hex(self.dptr)]
+            except ValueError:
+                str_list += ['dptr : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def poolProps(self):
         return self._poolProps
     @poolProps.setter
     def poolProps(self, poolProps not None : cudaMemPoolProps):
-        pass
-        for _attr in dir(poolProps):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._poolProps, _attr, getattr(poolProps, _attr))
+        string.memcpy(&self._ptr[0].poolProps, <cyruntime.cudaMemPoolProps*><void_ptr>poolProps.getPtr(), sizeof(self._ptr[0].poolProps))
     @property
     def accessDescs(self):
-        arrs = [<void_ptr>self._ptr[0].accessDescs + x*sizeof(ccudart.cudaMemAccessDesc) for x in range(self._accessDescs_length)]
+        arrs = [<void_ptr>self._ptr[0].accessDescs + x*sizeof(cyruntime.cudaMemAccessDesc) for x in range(self._accessDescs_length)]
         return [cudaMemAccessDesc(_ptr=arr) for arr in arrs]
     @accessDescs.setter
     def accessDescs(self, val):
@@ -6342,40 +6594,38 @@ cdef class cudaMemAllocNodeParams:
         else:
             if self._accessDescs_length != <size_t>len(val):
                 free(self._accessDescs)
-                self._accessDescs = <ccudart.cudaMemAccessDesc*> calloc(len(val), sizeof(ccudart.cudaMemAccessDesc))
+                self._accessDescs = <cyruntime.cudaMemAccessDesc*> calloc(len(val), sizeof(cyruntime.cudaMemAccessDesc))
                 if self._accessDescs is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccudart.cudaMemAccessDesc)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cyruntime.cudaMemAccessDesc)))
                 self._accessDescs_length = <size_t>len(val)
                 self._ptr[0].accessDescs = self._accessDescs
             for idx in range(len(val)):
-                memcpy(&self._accessDescs[idx], (<cudaMemAccessDesc>val[idx])._ptr, sizeof(ccudart.cudaMemAccessDesc))
+                string.memcpy(&self._accessDescs[idx], (<cudaMemAccessDesc>val[idx])._ptr, sizeof(cyruntime.cudaMemAccessDesc))
+
     @property
     def accessDescCount(self):
         return self._ptr[0].accessDescCount
     @accessDescCount.setter
     def accessDescCount(self, size_t accessDescCount):
-        pass
         self._ptr[0].accessDescCount = accessDescCount
     @property
     def bytesize(self):
         return self._ptr[0].bytesize
     @bytesize.setter
     def bytesize(self, size_t bytesize):
-        pass
         self._ptr[0].bytesize = bytesize
     @property
     def dptr(self):
         return <void_ptr>self._ptr[0].dptr
     @dptr.setter
     def dptr(self, dptr):
-        _cdptr = utils.HelperInputVoidPtr(dptr)
-        self._ptr[0].dptr = <void*><void_ptr>_cdptr.cptr
+        _cydptr = utils.HelperInputVoidPtr(dptr)
+        self._ptr[0].dptr = <void*><void_ptr>_cydptr.cptr
 {{endif}}
-{{if 'CUuuid_st' in found_types}}
+{{if 'struct CUuuid_st' in found_types}}
 
 cdef class CUuuid_st:
     """
-
     Attributes
     ----------
     bytes : bytes
@@ -6391,7 +6641,7 @@ cdef class CUuuid_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.CUuuid_st *>_ptr
+            self._ptr = <cyruntime.CUuuid_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -6401,16 +6651,19 @@ cdef class CUuuid_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['bytes : ' + str(self.bytes.hex())]
+            try:
+                str_list += ['bytes : ' + str(self.bytes.hex())]
+            except ValueError:
+                str_list += ['bytes : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def bytes(self):
         return PyBytes_FromStringAndSize(self._ptr[0].bytes, 16)
+
 {{endif}}
-{{if 'cudaDeviceProp' in found_types}}
+{{if 'struct cudaDeviceProp' in found_types}}
 
 cdef class cudaDeviceProp:
     """
@@ -6418,7 +6671,7 @@ cdef class cudaDeviceProp:
 
     Attributes
     ----------
-    name : List[char]
+    name : bytes
         ASCII string identifying device
     uuid : cudaUUID_t
         16-byte unique identifier
@@ -6605,7 +6858,7 @@ cdef class cudaDeviceProp:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaDeviceProp *>_ptr
+            self._ptr = <cyruntime.cudaDeviceProp *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._uuid = cudaUUID_t(_ptr=<void_ptr>&self._ptr[0].uuid)
     def __dealloc__(self):
@@ -6615,90 +6868,329 @@ cdef class cudaDeviceProp:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['name : ' + self.name.decode('utf-8')]
-            str_list += ['uuid :\n' + '\n'.join(['    ' + line for line in str(self.uuid).splitlines()])]
-            str_list += ['luid : ' + self.luid.hex()]
-            str_list += ['luidDeviceNodeMask : ' + str(self.luidDeviceNodeMask)]
-            str_list += ['totalGlobalMem : ' + str(self.totalGlobalMem)]
-            str_list += ['sharedMemPerBlock : ' + str(self.sharedMemPerBlock)]
-            str_list += ['regsPerBlock : ' + str(self.regsPerBlock)]
-            str_list += ['warpSize : ' + str(self.warpSize)]
-            str_list += ['memPitch : ' + str(self.memPitch)]
-            str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]
-            str_list += ['maxThreadsDim : ' + str(self.maxThreadsDim)]
-            str_list += ['maxGridSize : ' + str(self.maxGridSize)]
-            str_list += ['clockRate : ' + str(self.clockRate)]
-            str_list += ['totalConstMem : ' + str(self.totalConstMem)]
-            str_list += ['major : ' + str(self.major)]
-            str_list += ['minor : ' + str(self.minor)]
-            str_list += ['textureAlignment : ' + str(self.textureAlignment)]
-            str_list += ['texturePitchAlignment : ' + str(self.texturePitchAlignment)]
-            str_list += ['deviceOverlap : ' + str(self.deviceOverlap)]
-            str_list += ['multiProcessorCount : ' + str(self.multiProcessorCount)]
-            str_list += ['kernelExecTimeoutEnabled : ' + str(self.kernelExecTimeoutEnabled)]
-            str_list += ['integrated : ' + str(self.integrated)]
-            str_list += ['canMapHostMemory : ' + str(self.canMapHostMemory)]
-            str_list += ['computeMode : ' + str(self.computeMode)]
-            str_list += ['maxTexture1D : ' + str(self.maxTexture1D)]
-            str_list += ['maxTexture1DMipmap : ' + str(self.maxTexture1DMipmap)]
-            str_list += ['maxTexture1DLinear : ' + str(self.maxTexture1DLinear)]
-            str_list += ['maxTexture2D : ' + str(self.maxTexture2D)]
-            str_list += ['maxTexture2DMipmap : ' + str(self.maxTexture2DMipmap)]
-            str_list += ['maxTexture2DLinear : ' + str(self.maxTexture2DLinear)]
-            str_list += ['maxTexture2DGather : ' + str(self.maxTexture2DGather)]
-            str_list += ['maxTexture3D : ' + str(self.maxTexture3D)]
-            str_list += ['maxTexture3DAlt : ' + str(self.maxTexture3DAlt)]
-            str_list += ['maxTextureCubemap : ' + str(self.maxTextureCubemap)]
-            str_list += ['maxTexture1DLayered : ' + str(self.maxTexture1DLayered)]
-            str_list += ['maxTexture2DLayered : ' + str(self.maxTexture2DLayered)]
-            str_list += ['maxTextureCubemapLayered : ' + str(self.maxTextureCubemapLayered)]
-            str_list += ['maxSurface1D : ' + str(self.maxSurface1D)]
-            str_list += ['maxSurface2D : ' + str(self.maxSurface2D)]
-            str_list += ['maxSurface3D : ' + str(self.maxSurface3D)]
-            str_list += ['maxSurface1DLayered : ' + str(self.maxSurface1DLayered)]
-            str_list += ['maxSurface2DLayered : ' + str(self.maxSurface2DLayered)]
-            str_list += ['maxSurfaceCubemap : ' + str(self.maxSurfaceCubemap)]
-            str_list += ['maxSurfaceCubemapLayered : ' + str(self.maxSurfaceCubemapLayered)]
-            str_list += ['surfaceAlignment : ' + str(self.surfaceAlignment)]
-            str_list += ['concurrentKernels : ' + str(self.concurrentKernels)]
-            str_list += ['ECCEnabled : ' + str(self.ECCEnabled)]
-            str_list += ['pciBusID : ' + str(self.pciBusID)]
-            str_list += ['pciDeviceID : ' + str(self.pciDeviceID)]
-            str_list += ['pciDomainID : ' + str(self.pciDomainID)]
-            str_list += ['tccDriver : ' + str(self.tccDriver)]
-            str_list += ['asyncEngineCount : ' + str(self.asyncEngineCount)]
-            str_list += ['unifiedAddressing : ' + str(self.unifiedAddressing)]
-            str_list += ['memoryClockRate : ' + str(self.memoryClockRate)]
-            str_list += ['memoryBusWidth : ' + str(self.memoryBusWidth)]
-            str_list += ['l2CacheSize : ' + str(self.l2CacheSize)]
-            str_list += ['persistingL2CacheMaxSize : ' + str(self.persistingL2CacheMaxSize)]
-            str_list += ['maxThreadsPerMultiProcessor : ' + str(self.maxThreadsPerMultiProcessor)]
-            str_list += ['streamPrioritiesSupported : ' + str(self.streamPrioritiesSupported)]
-            str_list += ['globalL1CacheSupported : ' + str(self.globalL1CacheSupported)]
-            str_list += ['localL1CacheSupported : ' + str(self.localL1CacheSupported)]
-            str_list += ['sharedMemPerMultiprocessor : ' + str(self.sharedMemPerMultiprocessor)]
-            str_list += ['regsPerMultiprocessor : ' + str(self.regsPerMultiprocessor)]
-            str_list += ['managedMemory : ' + str(self.managedMemory)]
-            str_list += ['isMultiGpuBoard : ' + str(self.isMultiGpuBoard)]
-            str_list += ['multiGpuBoardGroupID : ' + str(self.multiGpuBoardGroupID)]
-            str_list += ['hostNativeAtomicSupported : ' + str(self.hostNativeAtomicSupported)]
-            str_list += ['singleToDoublePrecisionPerfRatio : ' + str(self.singleToDoublePrecisionPerfRatio)]
-            str_list += ['pageableMemoryAccess : ' + str(self.pageableMemoryAccess)]
-            str_list += ['concurrentManagedAccess : ' + str(self.concurrentManagedAccess)]
-            str_list += ['computePreemptionSupported : ' + str(self.computePreemptionSupported)]
-            str_list += ['canUseHostPointerForRegisteredMem : ' + str(self.canUseHostPointerForRegisteredMem)]
-            str_list += ['cooperativeLaunch : ' + str(self.cooperativeLaunch)]
-            str_list += ['cooperativeMultiDeviceLaunch : ' + str(self.cooperativeMultiDeviceLaunch)]
-            str_list += ['sharedMemPerBlockOptin : ' + str(self.sharedMemPerBlockOptin)]
-            str_list += ['pageableMemoryAccessUsesHostPageTables : ' + str(self.pageableMemoryAccessUsesHostPageTables)]
-            str_list += ['directManagedMemAccessFromHost : ' + str(self.directManagedMemAccessFromHost)]
-            str_list += ['maxBlocksPerMultiProcessor : ' + str(self.maxBlocksPerMultiProcessor)]
-            str_list += ['accessPolicyMaxWindowSize : ' + str(self.accessPolicyMaxWindowSize)]
-            str_list += ['reservedSharedMemPerBlock : ' + str(self.reservedSharedMemPerBlock)]
+            try:
+                str_list += ['name : ' + self.name.decode('utf-8')]
+            except ValueError:
+                str_list += ['name : <ValueError>']
+            try:
+                str_list += ['uuid :\n' + '\n'.join(['    ' + line for line in str(self.uuid).splitlines()])]
+            except ValueError:
+                str_list += ['uuid : <ValueError>']
+            try:
+                str_list += ['luid : ' + self.luid.hex()]
+            except ValueError:
+                str_list += ['luid : <ValueError>']
+            try:
+                str_list += ['luidDeviceNodeMask : ' + str(self.luidDeviceNodeMask)]
+            except ValueError:
+                str_list += ['luidDeviceNodeMask : <ValueError>']
+            try:
+                str_list += ['totalGlobalMem : ' + str(self.totalGlobalMem)]
+            except ValueError:
+                str_list += ['totalGlobalMem : <ValueError>']
+            try:
+                str_list += ['sharedMemPerBlock : ' + str(self.sharedMemPerBlock)]
+            except ValueError:
+                str_list += ['sharedMemPerBlock : <ValueError>']
+            try:
+                str_list += ['regsPerBlock : ' + str(self.regsPerBlock)]
+            except ValueError:
+                str_list += ['regsPerBlock : <ValueError>']
+            try:
+                str_list += ['warpSize : ' + str(self.warpSize)]
+            except ValueError:
+                str_list += ['warpSize : <ValueError>']
+            try:
+                str_list += ['memPitch : ' + str(self.memPitch)]
+            except ValueError:
+                str_list += ['memPitch : <ValueError>']
+            try:
+                str_list += ['maxThreadsPerBlock : ' + str(self.maxThreadsPerBlock)]
+            except ValueError:
+                str_list += ['maxThreadsPerBlock : <ValueError>']
+            try:
+                str_list += ['maxThreadsDim : ' + str(self.maxThreadsDim)]
+            except ValueError:
+                str_list += ['maxThreadsDim : <ValueError>']
+            try:
+                str_list += ['maxGridSize : ' + str(self.maxGridSize)]
+            except ValueError:
+                str_list += ['maxGridSize : <ValueError>']
+            try:
+                str_list += ['clockRate : ' + str(self.clockRate)]
+            except ValueError:
+                str_list += ['clockRate : <ValueError>']
+            try:
+                str_list += ['totalConstMem : ' + str(self.totalConstMem)]
+            except ValueError:
+                str_list += ['totalConstMem : <ValueError>']
+            try:
+                str_list += ['major : ' + str(self.major)]
+            except ValueError:
+                str_list += ['major : <ValueError>']
+            try:
+                str_list += ['minor : ' + str(self.minor)]
+            except ValueError:
+                str_list += ['minor : <ValueError>']
+            try:
+                str_list += ['textureAlignment : ' + str(self.textureAlignment)]
+            except ValueError:
+                str_list += ['textureAlignment : <ValueError>']
+            try:
+                str_list += ['texturePitchAlignment : ' + str(self.texturePitchAlignment)]
+            except ValueError:
+                str_list += ['texturePitchAlignment : <ValueError>']
+            try:
+                str_list += ['deviceOverlap : ' + str(self.deviceOverlap)]
+            except ValueError:
+                str_list += ['deviceOverlap : <ValueError>']
+            try:
+                str_list += ['multiProcessorCount : ' + str(self.multiProcessorCount)]
+            except ValueError:
+                str_list += ['multiProcessorCount : <ValueError>']
+            try:
+                str_list += ['kernelExecTimeoutEnabled : ' + str(self.kernelExecTimeoutEnabled)]
+            except ValueError:
+                str_list += ['kernelExecTimeoutEnabled : <ValueError>']
+            try:
+                str_list += ['integrated : ' + str(self.integrated)]
+            except ValueError:
+                str_list += ['integrated : <ValueError>']
+            try:
+                str_list += ['canMapHostMemory : ' + str(self.canMapHostMemory)]
+            except ValueError:
+                str_list += ['canMapHostMemory : <ValueError>']
+            try:
+                str_list += ['computeMode : ' + str(self.computeMode)]
+            except ValueError:
+                str_list += ['computeMode : <ValueError>']
+            try:
+                str_list += ['maxTexture1D : ' + str(self.maxTexture1D)]
+            except ValueError:
+                str_list += ['maxTexture1D : <ValueError>']
+            try:
+                str_list += ['maxTexture1DMipmap : ' + str(self.maxTexture1DMipmap)]
+            except ValueError:
+                str_list += ['maxTexture1DMipmap : <ValueError>']
+            try:
+                str_list += ['maxTexture1DLinear : ' + str(self.maxTexture1DLinear)]
+            except ValueError:
+                str_list += ['maxTexture1DLinear : <ValueError>']
+            try:
+                str_list += ['maxTexture2D : ' + str(self.maxTexture2D)]
+            except ValueError:
+                str_list += ['maxTexture2D : <ValueError>']
+            try:
+                str_list += ['maxTexture2DMipmap : ' + str(self.maxTexture2DMipmap)]
+            except ValueError:
+                str_list += ['maxTexture2DMipmap : <ValueError>']
+            try:
+                str_list += ['maxTexture2DLinear : ' + str(self.maxTexture2DLinear)]
+            except ValueError:
+                str_list += ['maxTexture2DLinear : <ValueError>']
+            try:
+                str_list += ['maxTexture2DGather : ' + str(self.maxTexture2DGather)]
+            except ValueError:
+                str_list += ['maxTexture2DGather : <ValueError>']
+            try:
+                str_list += ['maxTexture3D : ' + str(self.maxTexture3D)]
+            except ValueError:
+                str_list += ['maxTexture3D : <ValueError>']
+            try:
+                str_list += ['maxTexture3DAlt : ' + str(self.maxTexture3DAlt)]
+            except ValueError:
+                str_list += ['maxTexture3DAlt : <ValueError>']
+            try:
+                str_list += ['maxTextureCubemap : ' + str(self.maxTextureCubemap)]
+            except ValueError:
+                str_list += ['maxTextureCubemap : <ValueError>']
+            try:
+                str_list += ['maxTexture1DLayered : ' + str(self.maxTexture1DLayered)]
+            except ValueError:
+                str_list += ['maxTexture1DLayered : <ValueError>']
+            try:
+                str_list += ['maxTexture2DLayered : ' + str(self.maxTexture2DLayered)]
+            except ValueError:
+                str_list += ['maxTexture2DLayered : <ValueError>']
+            try:
+                str_list += ['maxTextureCubemapLayered : ' + str(self.maxTextureCubemapLayered)]
+            except ValueError:
+                str_list += ['maxTextureCubemapLayered : <ValueError>']
+            try:
+                str_list += ['maxSurface1D : ' + str(self.maxSurface1D)]
+            except ValueError:
+                str_list += ['maxSurface1D : <ValueError>']
+            try:
+                str_list += ['maxSurface2D : ' + str(self.maxSurface2D)]
+            except ValueError:
+                str_list += ['maxSurface2D : <ValueError>']
+            try:
+                str_list += ['maxSurface3D : ' + str(self.maxSurface3D)]
+            except ValueError:
+                str_list += ['maxSurface3D : <ValueError>']
+            try:
+                str_list += ['maxSurface1DLayered : ' + str(self.maxSurface1DLayered)]
+            except ValueError:
+                str_list += ['maxSurface1DLayered : <ValueError>']
+            try:
+                str_list += ['maxSurface2DLayered : ' + str(self.maxSurface2DLayered)]
+            except ValueError:
+                str_list += ['maxSurface2DLayered : <ValueError>']
+            try:
+                str_list += ['maxSurfaceCubemap : ' + str(self.maxSurfaceCubemap)]
+            except ValueError:
+                str_list += ['maxSurfaceCubemap : <ValueError>']
+            try:
+                str_list += ['maxSurfaceCubemapLayered : ' + str(self.maxSurfaceCubemapLayered)]
+            except ValueError:
+                str_list += ['maxSurfaceCubemapLayered : <ValueError>']
+            try:
+                str_list += ['surfaceAlignment : ' + str(self.surfaceAlignment)]
+            except ValueError:
+                str_list += ['surfaceAlignment : <ValueError>']
+            try:
+                str_list += ['concurrentKernels : ' + str(self.concurrentKernels)]
+            except ValueError:
+                str_list += ['concurrentKernels : <ValueError>']
+            try:
+                str_list += ['ECCEnabled : ' + str(self.ECCEnabled)]
+            except ValueError:
+                str_list += ['ECCEnabled : <ValueError>']
+            try:
+                str_list += ['pciBusID : ' + str(self.pciBusID)]
+            except ValueError:
+                str_list += ['pciBusID : <ValueError>']
+            try:
+                str_list += ['pciDeviceID : ' + str(self.pciDeviceID)]
+            except ValueError:
+                str_list += ['pciDeviceID : <ValueError>']
+            try:
+                str_list += ['pciDomainID : ' + str(self.pciDomainID)]
+            except ValueError:
+                str_list += ['pciDomainID : <ValueError>']
+            try:
+                str_list += ['tccDriver : ' + str(self.tccDriver)]
+            except ValueError:
+                str_list += ['tccDriver : <ValueError>']
+            try:
+                str_list += ['asyncEngineCount : ' + str(self.asyncEngineCount)]
+            except ValueError:
+                str_list += ['asyncEngineCount : <ValueError>']
+            try:
+                str_list += ['unifiedAddressing : ' + str(self.unifiedAddressing)]
+            except ValueError:
+                str_list += ['unifiedAddressing : <ValueError>']
+            try:
+                str_list += ['memoryClockRate : ' + str(self.memoryClockRate)]
+            except ValueError:
+                str_list += ['memoryClockRate : <ValueError>']
+            try:
+                str_list += ['memoryBusWidth : ' + str(self.memoryBusWidth)]
+            except ValueError:
+                str_list += ['memoryBusWidth : <ValueError>']
+            try:
+                str_list += ['l2CacheSize : ' + str(self.l2CacheSize)]
+            except ValueError:
+                str_list += ['l2CacheSize : <ValueError>']
+            try:
+                str_list += ['persistingL2CacheMaxSize : ' + str(self.persistingL2CacheMaxSize)]
+            except ValueError:
+                str_list += ['persistingL2CacheMaxSize : <ValueError>']
+            try:
+                str_list += ['maxThreadsPerMultiProcessor : ' + str(self.maxThreadsPerMultiProcessor)]
+            except ValueError:
+                str_list += ['maxThreadsPerMultiProcessor : <ValueError>']
+            try:
+                str_list += ['streamPrioritiesSupported : ' + str(self.streamPrioritiesSupported)]
+            except ValueError:
+                str_list += ['streamPrioritiesSupported : <ValueError>']
+            try:
+                str_list += ['globalL1CacheSupported : ' + str(self.globalL1CacheSupported)]
+            except ValueError:
+                str_list += ['globalL1CacheSupported : <ValueError>']
+            try:
+                str_list += ['localL1CacheSupported : ' + str(self.localL1CacheSupported)]
+            except ValueError:
+                str_list += ['localL1CacheSupported : <ValueError>']
+            try:
+                str_list += ['sharedMemPerMultiprocessor : ' + str(self.sharedMemPerMultiprocessor)]
+            except ValueError:
+                str_list += ['sharedMemPerMultiprocessor : <ValueError>']
+            try:
+                str_list += ['regsPerMultiprocessor : ' + str(self.regsPerMultiprocessor)]
+            except ValueError:
+                str_list += ['regsPerMultiprocessor : <ValueError>']
+            try:
+                str_list += ['managedMemory : ' + str(self.managedMemory)]
+            except ValueError:
+                str_list += ['managedMemory : <ValueError>']
+            try:
+                str_list += ['isMultiGpuBoard : ' + str(self.isMultiGpuBoard)]
+            except ValueError:
+                str_list += ['isMultiGpuBoard : <ValueError>']
+            try:
+                str_list += ['multiGpuBoardGroupID : ' + str(self.multiGpuBoardGroupID)]
+            except ValueError:
+                str_list += ['multiGpuBoardGroupID : <ValueError>']
+            try:
+                str_list += ['hostNativeAtomicSupported : ' + str(self.hostNativeAtomicSupported)]
+            except ValueError:
+                str_list += ['hostNativeAtomicSupported : <ValueError>']
+            try:
+                str_list += ['singleToDoublePrecisionPerfRatio : ' + str(self.singleToDoublePrecisionPerfRatio)]
+            except ValueError:
+                str_list += ['singleToDoublePrecisionPerfRatio : <ValueError>']
+            try:
+                str_list += ['pageableMemoryAccess : ' + str(self.pageableMemoryAccess)]
+            except ValueError:
+                str_list += ['pageableMemoryAccess : <ValueError>']
+            try:
+                str_list += ['concurrentManagedAccess : ' + str(self.concurrentManagedAccess)]
+            except ValueError:
+                str_list += ['concurrentManagedAccess : <ValueError>']
+            try:
+                str_list += ['computePreemptionSupported : ' + str(self.computePreemptionSupported)]
+            except ValueError:
+                str_list += ['computePreemptionSupported : <ValueError>']
+            try:
+                str_list += ['canUseHostPointerForRegisteredMem : ' + str(self.canUseHostPointerForRegisteredMem)]
+            except ValueError:
+                str_list += ['canUseHostPointerForRegisteredMem : <ValueError>']
+            try:
+                str_list += ['cooperativeLaunch : ' + str(self.cooperativeLaunch)]
+            except ValueError:
+                str_list += ['cooperativeLaunch : <ValueError>']
+            try:
+                str_list += ['cooperativeMultiDeviceLaunch : ' + str(self.cooperativeMultiDeviceLaunch)]
+            except ValueError:
+                str_list += ['cooperativeMultiDeviceLaunch : <ValueError>']
+            try:
+                str_list += ['sharedMemPerBlockOptin : ' + str(self.sharedMemPerBlockOptin)]
+            except ValueError:
+                str_list += ['sharedMemPerBlockOptin : <ValueError>']
+            try:
+                str_list += ['pageableMemoryAccessUsesHostPageTables : ' + str(self.pageableMemoryAccessUsesHostPageTables)]
+            except ValueError:
+                str_list += ['pageableMemoryAccessUsesHostPageTables : <ValueError>']
+            try:
+                str_list += ['directManagedMemAccessFromHost : ' + str(self.directManagedMemAccessFromHost)]
+            except ValueError:
+                str_list += ['directManagedMemAccessFromHost : <ValueError>']
+            try:
+                str_list += ['maxBlocksPerMultiProcessor : ' + str(self.maxBlocksPerMultiProcessor)]
+            except ValueError:
+                str_list += ['maxBlocksPerMultiProcessor : <ValueError>']
+            try:
+                str_list += ['accessPolicyMaxWindowSize : ' + str(self.accessPolicyMaxWindowSize)]
+            except ValueError:
+                str_list += ['accessPolicyMaxWindowSize : <ValueError>']
+            try:
+                str_list += ['reservedSharedMemPerBlock : ' + str(self.reservedSharedMemPerBlock)]
+            except ValueError:
+                str_list += ['reservedSharedMemPerBlock : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def name(self):
         return self._ptr[0].name
@@ -6711,12 +7203,7 @@ cdef class cudaDeviceProp:
         return self._uuid
     @uuid.setter
     def uuid(self, uuid not None : cudaUUID_t):
-        pass
-        for _attr in dir(uuid):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._uuid, _attr, getattr(uuid, _attr))
+        string.memcpy(&self._ptr[0].uuid, <cyruntime.cudaUUID_t*><void_ptr>uuid.getPtr(), sizeof(self._ptr[0].uuid))
     @property
     def luid(self):
         return PyBytes_FromStringAndSize(self._ptr[0].luid, 8)
@@ -6739,542 +7226,465 @@ cdef class cudaDeviceProp:
         return self._ptr[0].luidDeviceNodeMask
     @luidDeviceNodeMask.setter
     def luidDeviceNodeMask(self, unsigned int luidDeviceNodeMask):
-        pass
         self._ptr[0].luidDeviceNodeMask = luidDeviceNodeMask
     @property
     def totalGlobalMem(self):
         return self._ptr[0].totalGlobalMem
     @totalGlobalMem.setter
     def totalGlobalMem(self, size_t totalGlobalMem):
-        pass
         self._ptr[0].totalGlobalMem = totalGlobalMem
     @property
     def sharedMemPerBlock(self):
         return self._ptr[0].sharedMemPerBlock
     @sharedMemPerBlock.setter
     def sharedMemPerBlock(self, size_t sharedMemPerBlock):
-        pass
         self._ptr[0].sharedMemPerBlock = sharedMemPerBlock
     @property
     def regsPerBlock(self):
         return self._ptr[0].regsPerBlock
     @regsPerBlock.setter
     def regsPerBlock(self, int regsPerBlock):
-        pass
         self._ptr[0].regsPerBlock = regsPerBlock
     @property
     def warpSize(self):
         return self._ptr[0].warpSize
     @warpSize.setter
     def warpSize(self, int warpSize):
-        pass
         self._ptr[0].warpSize = warpSize
     @property
     def memPitch(self):
         return self._ptr[0].memPitch
     @memPitch.setter
     def memPitch(self, size_t memPitch):
-        pass
         self._ptr[0].memPitch = memPitch
     @property
     def maxThreadsPerBlock(self):
         return self._ptr[0].maxThreadsPerBlock
     @maxThreadsPerBlock.setter
     def maxThreadsPerBlock(self, int maxThreadsPerBlock):
-        pass
         self._ptr[0].maxThreadsPerBlock = maxThreadsPerBlock
     @property
     def maxThreadsDim(self):
         return self._ptr[0].maxThreadsDim
     @maxThreadsDim.setter
     def maxThreadsDim(self, maxThreadsDim):
-        pass
         self._ptr[0].maxThreadsDim = maxThreadsDim
     @property
     def maxGridSize(self):
         return self._ptr[0].maxGridSize
     @maxGridSize.setter
     def maxGridSize(self, maxGridSize):
-        pass
         self._ptr[0].maxGridSize = maxGridSize
     @property
     def clockRate(self):
         return self._ptr[0].clockRate
     @clockRate.setter
     def clockRate(self, int clockRate):
-        pass
         self._ptr[0].clockRate = clockRate
     @property
     def totalConstMem(self):
         return self._ptr[0].totalConstMem
     @totalConstMem.setter
     def totalConstMem(self, size_t totalConstMem):
-        pass
         self._ptr[0].totalConstMem = totalConstMem
     @property
     def major(self):
         return self._ptr[0].major
     @major.setter
     def major(self, int major):
-        pass
         self._ptr[0].major = major
     @property
     def minor(self):
         return self._ptr[0].minor
     @minor.setter
     def minor(self, int minor):
-        pass
         self._ptr[0].minor = minor
     @property
     def textureAlignment(self):
         return self._ptr[0].textureAlignment
     @textureAlignment.setter
     def textureAlignment(self, size_t textureAlignment):
-        pass
         self._ptr[0].textureAlignment = textureAlignment
     @property
     def texturePitchAlignment(self):
         return self._ptr[0].texturePitchAlignment
     @texturePitchAlignment.setter
     def texturePitchAlignment(self, size_t texturePitchAlignment):
-        pass
         self._ptr[0].texturePitchAlignment = texturePitchAlignment
     @property
     def deviceOverlap(self):
         return self._ptr[0].deviceOverlap
     @deviceOverlap.setter
     def deviceOverlap(self, int deviceOverlap):
-        pass
         self._ptr[0].deviceOverlap = deviceOverlap
     @property
     def multiProcessorCount(self):
         return self._ptr[0].multiProcessorCount
     @multiProcessorCount.setter
     def multiProcessorCount(self, int multiProcessorCount):
-        pass
         self._ptr[0].multiProcessorCount = multiProcessorCount
     @property
     def kernelExecTimeoutEnabled(self):
         return self._ptr[0].kernelExecTimeoutEnabled
     @kernelExecTimeoutEnabled.setter
     def kernelExecTimeoutEnabled(self, int kernelExecTimeoutEnabled):
-        pass
         self._ptr[0].kernelExecTimeoutEnabled = kernelExecTimeoutEnabled
     @property
     def integrated(self):
         return self._ptr[0].integrated
     @integrated.setter
     def integrated(self, int integrated):
-        pass
         self._ptr[0].integrated = integrated
     @property
     def canMapHostMemory(self):
         return self._ptr[0].canMapHostMemory
     @canMapHostMemory.setter
     def canMapHostMemory(self, int canMapHostMemory):
-        pass
         self._ptr[0].canMapHostMemory = canMapHostMemory
     @property
     def computeMode(self):
         return self._ptr[0].computeMode
     @computeMode.setter
     def computeMode(self, int computeMode):
-        pass
         self._ptr[0].computeMode = computeMode
     @property
     def maxTexture1D(self):
         return self._ptr[0].maxTexture1D
     @maxTexture1D.setter
     def maxTexture1D(self, int maxTexture1D):
-        pass
         self._ptr[0].maxTexture1D = maxTexture1D
     @property
     def maxTexture1DMipmap(self):
         return self._ptr[0].maxTexture1DMipmap
     @maxTexture1DMipmap.setter
     def maxTexture1DMipmap(self, int maxTexture1DMipmap):
-        pass
         self._ptr[0].maxTexture1DMipmap = maxTexture1DMipmap
     @property
     def maxTexture1DLinear(self):
         return self._ptr[0].maxTexture1DLinear
     @maxTexture1DLinear.setter
     def maxTexture1DLinear(self, int maxTexture1DLinear):
-        pass
         self._ptr[0].maxTexture1DLinear = maxTexture1DLinear
     @property
     def maxTexture2D(self):
         return self._ptr[0].maxTexture2D
     @maxTexture2D.setter
     def maxTexture2D(self, maxTexture2D):
-        pass
         self._ptr[0].maxTexture2D = maxTexture2D
     @property
     def maxTexture2DMipmap(self):
         return self._ptr[0].maxTexture2DMipmap
     @maxTexture2DMipmap.setter
     def maxTexture2DMipmap(self, maxTexture2DMipmap):
-        pass
         self._ptr[0].maxTexture2DMipmap = maxTexture2DMipmap
     @property
     def maxTexture2DLinear(self):
         return self._ptr[0].maxTexture2DLinear
     @maxTexture2DLinear.setter
     def maxTexture2DLinear(self, maxTexture2DLinear):
-        pass
         self._ptr[0].maxTexture2DLinear = maxTexture2DLinear
     @property
     def maxTexture2DGather(self):
         return self._ptr[0].maxTexture2DGather
     @maxTexture2DGather.setter
     def maxTexture2DGather(self, maxTexture2DGather):
-        pass
         self._ptr[0].maxTexture2DGather = maxTexture2DGather
     @property
     def maxTexture3D(self):
         return self._ptr[0].maxTexture3D
     @maxTexture3D.setter
     def maxTexture3D(self, maxTexture3D):
-        pass
         self._ptr[0].maxTexture3D = maxTexture3D
     @property
     def maxTexture3DAlt(self):
         return self._ptr[0].maxTexture3DAlt
     @maxTexture3DAlt.setter
     def maxTexture3DAlt(self, maxTexture3DAlt):
-        pass
         self._ptr[0].maxTexture3DAlt = maxTexture3DAlt
     @property
     def maxTextureCubemap(self):
         return self._ptr[0].maxTextureCubemap
     @maxTextureCubemap.setter
     def maxTextureCubemap(self, int maxTextureCubemap):
-        pass
         self._ptr[0].maxTextureCubemap = maxTextureCubemap
     @property
     def maxTexture1DLayered(self):
         return self._ptr[0].maxTexture1DLayered
     @maxTexture1DLayered.setter
     def maxTexture1DLayered(self, maxTexture1DLayered):
-        pass
         self._ptr[0].maxTexture1DLayered = maxTexture1DLayered
     @property
     def maxTexture2DLayered(self):
         return self._ptr[0].maxTexture2DLayered
     @maxTexture2DLayered.setter
     def maxTexture2DLayered(self, maxTexture2DLayered):
-        pass
         self._ptr[0].maxTexture2DLayered = maxTexture2DLayered
     @property
     def maxTextureCubemapLayered(self):
         return self._ptr[0].maxTextureCubemapLayered
     @maxTextureCubemapLayered.setter
     def maxTextureCubemapLayered(self, maxTextureCubemapLayered):
-        pass
         self._ptr[0].maxTextureCubemapLayered = maxTextureCubemapLayered
     @property
     def maxSurface1D(self):
         return self._ptr[0].maxSurface1D
     @maxSurface1D.setter
     def maxSurface1D(self, int maxSurface1D):
-        pass
         self._ptr[0].maxSurface1D = maxSurface1D
     @property
     def maxSurface2D(self):
         return self._ptr[0].maxSurface2D
     @maxSurface2D.setter
     def maxSurface2D(self, maxSurface2D):
-        pass
         self._ptr[0].maxSurface2D = maxSurface2D
     @property
     def maxSurface3D(self):
         return self._ptr[0].maxSurface3D
     @maxSurface3D.setter
     def maxSurface3D(self, maxSurface3D):
-        pass
         self._ptr[0].maxSurface3D = maxSurface3D
     @property
     def maxSurface1DLayered(self):
         return self._ptr[0].maxSurface1DLayered
     @maxSurface1DLayered.setter
     def maxSurface1DLayered(self, maxSurface1DLayered):
-        pass
         self._ptr[0].maxSurface1DLayered = maxSurface1DLayered
     @property
     def maxSurface2DLayered(self):
         return self._ptr[0].maxSurface2DLayered
     @maxSurface2DLayered.setter
     def maxSurface2DLayered(self, maxSurface2DLayered):
-        pass
         self._ptr[0].maxSurface2DLayered = maxSurface2DLayered
     @property
     def maxSurfaceCubemap(self):
         return self._ptr[0].maxSurfaceCubemap
     @maxSurfaceCubemap.setter
     def maxSurfaceCubemap(self, int maxSurfaceCubemap):
-        pass
         self._ptr[0].maxSurfaceCubemap = maxSurfaceCubemap
     @property
     def maxSurfaceCubemapLayered(self):
         return self._ptr[0].maxSurfaceCubemapLayered
     @maxSurfaceCubemapLayered.setter
     def maxSurfaceCubemapLayered(self, maxSurfaceCubemapLayered):
-        pass
         self._ptr[0].maxSurfaceCubemapLayered = maxSurfaceCubemapLayered
     @property
     def surfaceAlignment(self):
         return self._ptr[0].surfaceAlignment
     @surfaceAlignment.setter
     def surfaceAlignment(self, size_t surfaceAlignment):
-        pass
         self._ptr[0].surfaceAlignment = surfaceAlignment
     @property
     def concurrentKernels(self):
         return self._ptr[0].concurrentKernels
     @concurrentKernels.setter
     def concurrentKernels(self, int concurrentKernels):
-        pass
         self._ptr[0].concurrentKernels = concurrentKernels
     @property
     def ECCEnabled(self):
         return self._ptr[0].ECCEnabled
     @ECCEnabled.setter
     def ECCEnabled(self, int ECCEnabled):
-        pass
         self._ptr[0].ECCEnabled = ECCEnabled
     @property
     def pciBusID(self):
         return self._ptr[0].pciBusID
     @pciBusID.setter
     def pciBusID(self, int pciBusID):
-        pass
         self._ptr[0].pciBusID = pciBusID
     @property
     def pciDeviceID(self):
         return self._ptr[0].pciDeviceID
     @pciDeviceID.setter
     def pciDeviceID(self, int pciDeviceID):
-        pass
         self._ptr[0].pciDeviceID = pciDeviceID
     @property
     def pciDomainID(self):
         return self._ptr[0].pciDomainID
     @pciDomainID.setter
     def pciDomainID(self, int pciDomainID):
-        pass
         self._ptr[0].pciDomainID = pciDomainID
     @property
     def tccDriver(self):
         return self._ptr[0].tccDriver
     @tccDriver.setter
     def tccDriver(self, int tccDriver):
-        pass
         self._ptr[0].tccDriver = tccDriver
     @property
     def asyncEngineCount(self):
         return self._ptr[0].asyncEngineCount
     @asyncEngineCount.setter
     def asyncEngineCount(self, int asyncEngineCount):
-        pass
         self._ptr[0].asyncEngineCount = asyncEngineCount
     @property
     def unifiedAddressing(self):
         return self._ptr[0].unifiedAddressing
     @unifiedAddressing.setter
     def unifiedAddressing(self, int unifiedAddressing):
-        pass
         self._ptr[0].unifiedAddressing = unifiedAddressing
     @property
     def memoryClockRate(self):
         return self._ptr[0].memoryClockRate
     @memoryClockRate.setter
     def memoryClockRate(self, int memoryClockRate):
-        pass
         self._ptr[0].memoryClockRate = memoryClockRate
     @property
     def memoryBusWidth(self):
         return self._ptr[0].memoryBusWidth
     @memoryBusWidth.setter
     def memoryBusWidth(self, int memoryBusWidth):
-        pass
         self._ptr[0].memoryBusWidth = memoryBusWidth
     @property
     def l2CacheSize(self):
         return self._ptr[0].l2CacheSize
     @l2CacheSize.setter
     def l2CacheSize(self, int l2CacheSize):
-        pass
         self._ptr[0].l2CacheSize = l2CacheSize
     @property
     def persistingL2CacheMaxSize(self):
         return self._ptr[0].persistingL2CacheMaxSize
     @persistingL2CacheMaxSize.setter
     def persistingL2CacheMaxSize(self, int persistingL2CacheMaxSize):
-        pass
         self._ptr[0].persistingL2CacheMaxSize = persistingL2CacheMaxSize
     @property
     def maxThreadsPerMultiProcessor(self):
         return self._ptr[0].maxThreadsPerMultiProcessor
     @maxThreadsPerMultiProcessor.setter
     def maxThreadsPerMultiProcessor(self, int maxThreadsPerMultiProcessor):
-        pass
         self._ptr[0].maxThreadsPerMultiProcessor = maxThreadsPerMultiProcessor
     @property
     def streamPrioritiesSupported(self):
         return self._ptr[0].streamPrioritiesSupported
     @streamPrioritiesSupported.setter
     def streamPrioritiesSupported(self, int streamPrioritiesSupported):
-        pass
         self._ptr[0].streamPrioritiesSupported = streamPrioritiesSupported
     @property
     def globalL1CacheSupported(self):
         return self._ptr[0].globalL1CacheSupported
     @globalL1CacheSupported.setter
     def globalL1CacheSupported(self, int globalL1CacheSupported):
-        pass
         self._ptr[0].globalL1CacheSupported = globalL1CacheSupported
     @property
     def localL1CacheSupported(self):
         return self._ptr[0].localL1CacheSupported
     @localL1CacheSupported.setter
     def localL1CacheSupported(self, int localL1CacheSupported):
-        pass
         self._ptr[0].localL1CacheSupported = localL1CacheSupported
     @property
     def sharedMemPerMultiprocessor(self):
         return self._ptr[0].sharedMemPerMultiprocessor
     @sharedMemPerMultiprocessor.setter
     def sharedMemPerMultiprocessor(self, size_t sharedMemPerMultiprocessor):
-        pass
         self._ptr[0].sharedMemPerMultiprocessor = sharedMemPerMultiprocessor
     @property
     def regsPerMultiprocessor(self):
         return self._ptr[0].regsPerMultiprocessor
     @regsPerMultiprocessor.setter
     def regsPerMultiprocessor(self, int regsPerMultiprocessor):
-        pass
         self._ptr[0].regsPerMultiprocessor = regsPerMultiprocessor
     @property
     def managedMemory(self):
         return self._ptr[0].managedMemory
     @managedMemory.setter
     def managedMemory(self, int managedMemory):
-        pass
         self._ptr[0].managedMemory = managedMemory
     @property
     def isMultiGpuBoard(self):
         return self._ptr[0].isMultiGpuBoard
     @isMultiGpuBoard.setter
     def isMultiGpuBoard(self, int isMultiGpuBoard):
-        pass
         self._ptr[0].isMultiGpuBoard = isMultiGpuBoard
     @property
     def multiGpuBoardGroupID(self):
         return self._ptr[0].multiGpuBoardGroupID
     @multiGpuBoardGroupID.setter
     def multiGpuBoardGroupID(self, int multiGpuBoardGroupID):
-        pass
         self._ptr[0].multiGpuBoardGroupID = multiGpuBoardGroupID
     @property
     def hostNativeAtomicSupported(self):
         return self._ptr[0].hostNativeAtomicSupported
     @hostNativeAtomicSupported.setter
     def hostNativeAtomicSupported(self, int hostNativeAtomicSupported):
-        pass
         self._ptr[0].hostNativeAtomicSupported = hostNativeAtomicSupported
     @property
     def singleToDoublePrecisionPerfRatio(self):
         return self._ptr[0].singleToDoublePrecisionPerfRatio
     @singleToDoublePrecisionPerfRatio.setter
     def singleToDoublePrecisionPerfRatio(self, int singleToDoublePrecisionPerfRatio):
-        pass
         self._ptr[0].singleToDoublePrecisionPerfRatio = singleToDoublePrecisionPerfRatio
     @property
     def pageableMemoryAccess(self):
         return self._ptr[0].pageableMemoryAccess
     @pageableMemoryAccess.setter
     def pageableMemoryAccess(self, int pageableMemoryAccess):
-        pass
         self._ptr[0].pageableMemoryAccess = pageableMemoryAccess
     @property
     def concurrentManagedAccess(self):
         return self._ptr[0].concurrentManagedAccess
     @concurrentManagedAccess.setter
     def concurrentManagedAccess(self, int concurrentManagedAccess):
-        pass
         self._ptr[0].concurrentManagedAccess = concurrentManagedAccess
     @property
     def computePreemptionSupported(self):
         return self._ptr[0].computePreemptionSupported
     @computePreemptionSupported.setter
     def computePreemptionSupported(self, int computePreemptionSupported):
-        pass
         self._ptr[0].computePreemptionSupported = computePreemptionSupported
     @property
     def canUseHostPointerForRegisteredMem(self):
         return self._ptr[0].canUseHostPointerForRegisteredMem
     @canUseHostPointerForRegisteredMem.setter
     def canUseHostPointerForRegisteredMem(self, int canUseHostPointerForRegisteredMem):
-        pass
         self._ptr[0].canUseHostPointerForRegisteredMem = canUseHostPointerForRegisteredMem
     @property
     def cooperativeLaunch(self):
         return self._ptr[0].cooperativeLaunch
     @cooperativeLaunch.setter
     def cooperativeLaunch(self, int cooperativeLaunch):
-        pass
         self._ptr[0].cooperativeLaunch = cooperativeLaunch
     @property
     def cooperativeMultiDeviceLaunch(self):
         return self._ptr[0].cooperativeMultiDeviceLaunch
     @cooperativeMultiDeviceLaunch.setter
     def cooperativeMultiDeviceLaunch(self, int cooperativeMultiDeviceLaunch):
-        pass
         self._ptr[0].cooperativeMultiDeviceLaunch = cooperativeMultiDeviceLaunch
     @property
     def sharedMemPerBlockOptin(self):
         return self._ptr[0].sharedMemPerBlockOptin
     @sharedMemPerBlockOptin.setter
     def sharedMemPerBlockOptin(self, size_t sharedMemPerBlockOptin):
-        pass
         self._ptr[0].sharedMemPerBlockOptin = sharedMemPerBlockOptin
     @property
     def pageableMemoryAccessUsesHostPageTables(self):
         return self._ptr[0].pageableMemoryAccessUsesHostPageTables
     @pageableMemoryAccessUsesHostPageTables.setter
     def pageableMemoryAccessUsesHostPageTables(self, int pageableMemoryAccessUsesHostPageTables):
-        pass
         self._ptr[0].pageableMemoryAccessUsesHostPageTables = pageableMemoryAccessUsesHostPageTables
     @property
     def directManagedMemAccessFromHost(self):
         return self._ptr[0].directManagedMemAccessFromHost
     @directManagedMemAccessFromHost.setter
     def directManagedMemAccessFromHost(self, int directManagedMemAccessFromHost):
-        pass
         self._ptr[0].directManagedMemAccessFromHost = directManagedMemAccessFromHost
     @property
     def maxBlocksPerMultiProcessor(self):
         return self._ptr[0].maxBlocksPerMultiProcessor
     @maxBlocksPerMultiProcessor.setter
     def maxBlocksPerMultiProcessor(self, int maxBlocksPerMultiProcessor):
-        pass
         self._ptr[0].maxBlocksPerMultiProcessor = maxBlocksPerMultiProcessor
     @property
     def accessPolicyMaxWindowSize(self):
         return self._ptr[0].accessPolicyMaxWindowSize
     @accessPolicyMaxWindowSize.setter
     def accessPolicyMaxWindowSize(self, int accessPolicyMaxWindowSize):
-        pass
         self._ptr[0].accessPolicyMaxWindowSize = accessPolicyMaxWindowSize
     @property
     def reservedSharedMemPerBlock(self):
         return self._ptr[0].reservedSharedMemPerBlock
     @reservedSharedMemPerBlock.setter
     def reservedSharedMemPerBlock(self, size_t reservedSharedMemPerBlock):
-        pass
         self._ptr[0].reservedSharedMemPerBlock = reservedSharedMemPerBlock
 {{endif}}
-{{if 'cudaIpcEventHandle_st' in found_types}}
+{{if 'struct cudaIpcEventHandle_st' in found_types}}
 
 cdef class cudaIpcEventHandle_st:
     """
@@ -7295,7 +7705,7 @@ cdef class cudaIpcEventHandle_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaIpcEventHandle_st *>_ptr
+            self._ptr = <cyruntime.cudaIpcEventHandle_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -7305,11 +7715,13 @@ cdef class cudaIpcEventHandle_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(self._ptr[0].reserved, 64)
@@ -7328,7 +7740,7 @@ cdef class cudaIpcEventHandle_st:
                     b = b - 256
                 self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'cudaIpcMemHandle_st' in found_types}}
+{{if 'struct cudaIpcMemHandle_st' in found_types}}
 
 cdef class cudaIpcMemHandle_st:
     """
@@ -7349,7 +7761,7 @@ cdef class cudaIpcMemHandle_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaIpcMemHandle_st *>_ptr
+            self._ptr = <cyruntime.cudaIpcMemHandle_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -7359,11 +7771,13 @@ cdef class cudaIpcMemHandle_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def reserved(self):
         return PyBytes_FromStringAndSize(self._ptr[0].reserved, 64)
@@ -7382,16 +7796,15 @@ cdef class cudaIpcMemHandle_st:
                     b = b - 256
                 self._ptr[0].reserved[i] = b
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
-cdef class _cudaExternalMemoryHandleDesc_handle_handle_win32_s:
+cdef class anon_struct5:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -7401,47 +7814,54 @@ cdef class _cudaExternalMemoryHandleDesc_handle_handle_win32_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalMemoryHandleDesc *>_ptr
+        self._ptr = <cyruntime.cudaExternalMemoryHandleDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle.win32
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['handle : ' + hex(self.handle)]
-            str_list += ['name : ' + hex(self.name)]
+            try:
+                str_list += ['handle : ' + hex(self.handle)]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['name : ' + hex(self.name)]
+            except ValueError:
+                str_list += ['name : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def handle(self):
         return <void_ptr>self._ptr[0].handle.win32.handle
     @handle.setter
     def handle(self, handle):
-        _chandle = utils.HelperInputVoidPtr(handle)
-        self._ptr[0].handle.win32.handle = <void*><void_ptr>_chandle.cptr
+        _cyhandle = utils.HelperInputVoidPtr(handle)
+        self._ptr[0].handle.win32.handle = <void*><void_ptr>_cyhandle.cptr
     @property
     def name(self):
         return <void_ptr>self._ptr[0].handle.win32.name
     @name.setter
     def name(self, name):
-        _cname = utils.HelperInputVoidPtr(name)
-        self._ptr[0].handle.win32.name = <void*><void_ptr>_cname.cptr
+        _cyname = utils.HelperInputVoidPtr(name)
+        self._ptr[0].handle.win32.name = <void*><void_ptr>_cyname.cptr
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
-cdef class _cudaExternalMemoryHandleDesc_handle_u:
+cdef class anon_union1:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _cudaExternalMemoryHandleDesc_handle_handle_win32_s
+    win32 : anon_struct5
 
-    nvSciBufObject : void
+    nvSciBufObject : Any
 
 
     Methods
@@ -7451,48 +7871,53 @@ cdef class _cudaExternalMemoryHandleDesc_handle_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalMemoryHandleDesc *>_ptr
+        self._ptr = <cyruntime.cudaExternalMemoryHandleDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._win32 = _cudaExternalMemoryHandleDesc_handle_handle_win32_s(_ptr=<void_ptr>self._ptr)
+        self._win32 = anon_struct5(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fd : ' + str(self.fd)]
-            str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
-            str_list += ['nvSciBufObject : ' + hex(self.nvSciBufObject)]
+            try:
+                str_list += ['fd : ' + str(self.fd)]
+            except ValueError:
+                str_list += ['fd : <ValueError>']
+            try:
+                str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
+            except ValueError:
+                str_list += ['win32 : <ValueError>']
+            try:
+                str_list += ['nvSciBufObject : ' + hex(self.nvSciBufObject)]
+            except ValueError:
+                str_list += ['nvSciBufObject : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fd(self):
         return self._ptr[0].handle.fd
     @fd.setter
     def fd(self, int fd):
-        pass
         self._ptr[0].handle.fd = fd
     @property
     def win32(self):
         return self._win32
     @win32.setter
-    def win32(self, win32 not None : _cudaExternalMemoryHandleDesc_handle_handle_win32_s):
-        pass
-        for _attr in dir(win32):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._win32, _attr, getattr(win32, _attr))
+    def win32(self, win32 not None : anon_struct5):
+        string.memcpy(&self._ptr[0].handle.win32, <cyruntime.anon_struct5*><void_ptr>win32.getPtr(), sizeof(self._ptr[0].handle.win32))
     @property
     def nvSciBufObject(self):
         return <void_ptr>self._ptr[0].handle.nvSciBufObject
     @nvSciBufObject.setter
     def nvSciBufObject(self, nvSciBufObject):
-        _cnvSciBufObject = utils.HelperInputVoidPtr(nvSciBufObject)
-        self._ptr[0].handle.nvSciBufObject = <void*><void_ptr>_cnvSciBufObject.cptr
+        _cynvSciBufObject = utils.HelperInputVoidPtr(nvSciBufObject)
+        self._ptr[0].handle.nvSciBufObject = <void*><void_ptr>_cynvSciBufObject.cptr
 {{endif}}
-{{if 'cudaExternalMemoryHandleDesc' in found_types}}
+{{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
 
 cdef class cudaExternalMemoryHandleDesc:
     """
@@ -7502,7 +7927,7 @@ cdef class cudaExternalMemoryHandleDesc:
     ----------
     type : cudaExternalMemoryHandleType
         Type of the handle
-    handle : _cudaExternalMemoryHandleDesc_handle_u
+    handle : anon_union1
 
     size : unsigned long long
         Size of the memory allocation
@@ -7517,60 +7942,65 @@ cdef class cudaExternalMemoryHandleDesc:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cyruntime.cudaExternalMemoryHandleDesc *>calloc(1, sizeof(cyruntime.cudaExternalMemoryHandleDesc))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccudart.cudaExternalMemoryHandleDesc *>_ptr
+            self._ptr = <cyruntime.cudaExternalMemoryHandleDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._handle = _cudaExternalMemoryHandleDesc_handle_u(_ptr=<void_ptr>self._ptr)
+        self._handle = anon_union1(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return cudaExternalMemoryHandleType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : cudaExternalMemoryHandleType):
-        pass
         self._ptr[0].type = type.value
     @property
     def handle(self):
         return self._handle
     @handle.setter
-    def handle(self, handle not None : _cudaExternalMemoryHandleDesc_handle_u):
-        pass
-        for _attr in dir(handle):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._handle, _attr, getattr(handle, _attr))
+    def handle(self, handle not None : anon_union1):
+        string.memcpy(&self._ptr[0].handle, <cyruntime.anon_union1*><void_ptr>handle.getPtr(), sizeof(self._ptr[0].handle))
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, unsigned long long size):
-        pass
         self._ptr[0].size = size
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
 {{endif}}
-{{if 'cudaExternalMemoryBufferDesc' in found_types}}
+{{if 'struct cudaExternalMemoryBufferDesc' in found_types}}
 
 cdef class cudaExternalMemoryBufferDesc:
     """
@@ -7595,7 +8025,7 @@ cdef class cudaExternalMemoryBufferDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalMemoryBufferDesc *>_ptr
+            self._ptr = <cyruntime.cudaExternalMemoryBufferDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -7605,36 +8035,41 @@ cdef class cudaExternalMemoryBufferDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['size : ' + str(self.size)]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['size : ' + str(self.size)]
+            except ValueError:
+                str_list += ['size : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def offset(self):
         return self._ptr[0].offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].offset = offset
     @property
     def size(self):
         return self._ptr[0].size
     @size.setter
     def size(self, unsigned long long size):
-        pass
         self._ptr[0].size = size
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
 {{endif}}
-{{if 'cudaExternalMemoryMipmappedArrayDesc' in found_types}}
+{{if 'struct cudaExternalMemoryMipmappedArrayDesc' in found_types}}
 
 cdef class cudaExternalMemoryMipmappedArrayDesc:
     """
@@ -7665,7 +8100,7 @@ cdef class cudaExternalMemoryMipmappedArrayDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalMemoryMipmappedArrayDesc *>_ptr
+            self._ptr = <cyruntime.cudaExternalMemoryMipmappedArrayDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._formatDesc = cudaChannelFormatDesc(_ptr=<void_ptr>&self._ptr[0].formatDesc)
         self._extent = cudaExtent(_ptr=<void_ptr>&self._ptr[0].extent)
@@ -7676,69 +8111,69 @@ cdef class cudaExternalMemoryMipmappedArrayDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['offset : ' + str(self.offset)]
-            str_list += ['formatDesc :\n' + '\n'.join(['    ' + line for line in str(self.formatDesc).splitlines()])]
-            str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['numLevels : ' + str(self.numLevels)]
+            try:
+                str_list += ['offset : ' + str(self.offset)]
+            except ValueError:
+                str_list += ['offset : <ValueError>']
+            try:
+                str_list += ['formatDesc :\n' + '\n'.join(['    ' + line for line in str(self.formatDesc).splitlines()])]
+            except ValueError:
+                str_list += ['formatDesc : <ValueError>']
+            try:
+                str_list += ['extent :\n' + '\n'.join(['    ' + line for line in str(self.extent).splitlines()])]
+            except ValueError:
+                str_list += ['extent : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['numLevels : ' + str(self.numLevels)]
+            except ValueError:
+                str_list += ['numLevels : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def offset(self):
         return self._ptr[0].offset
     @offset.setter
     def offset(self, unsigned long long offset):
-        pass
         self._ptr[0].offset = offset
     @property
     def formatDesc(self):
         return self._formatDesc
     @formatDesc.setter
     def formatDesc(self, formatDesc not None : cudaChannelFormatDesc):
-        pass
-        for _attr in dir(formatDesc):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._formatDesc, _attr, getattr(formatDesc, _attr))
+        string.memcpy(&self._ptr[0].formatDesc, <cyruntime.cudaChannelFormatDesc*><void_ptr>formatDesc.getPtr(), sizeof(self._ptr[0].formatDesc))
     @property
     def extent(self):
         return self._extent
     @extent.setter
     def extent(self, extent not None : cudaExtent):
-        pass
-        for _attr in dir(extent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._extent, _attr, getattr(extent, _attr))
+        string.memcpy(&self._ptr[0].extent, <cyruntime.cudaExtent*><void_ptr>extent.getPtr(), sizeof(self._ptr[0].extent))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def numLevels(self):
         return self._ptr[0].numLevels
     @numLevels.setter
     def numLevels(self, unsigned int numLevels):
-        pass
         self._ptr[0].numLevels = numLevels
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
-cdef class _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s:
+cdef class anon_struct6:
     """
-
     Attributes
     ----------
-    handle : void
+    handle : Any
 
-    name : void
+    name : Any
 
 
     Methods
@@ -7748,47 +8183,54 @@ cdef class _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreHandleDesc *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreHandleDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle.win32
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['handle : ' + hex(self.handle)]
-            str_list += ['name : ' + hex(self.name)]
+            try:
+                str_list += ['handle : ' + hex(self.handle)]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['name : ' + hex(self.name)]
+            except ValueError:
+                str_list += ['name : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def handle(self):
         return <void_ptr>self._ptr[0].handle.win32.handle
     @handle.setter
     def handle(self, handle):
-        _chandle = utils.HelperInputVoidPtr(handle)
-        self._ptr[0].handle.win32.handle = <void*><void_ptr>_chandle.cptr
+        _cyhandle = utils.HelperInputVoidPtr(handle)
+        self._ptr[0].handle.win32.handle = <void*><void_ptr>_cyhandle.cptr
     @property
     def name(self):
         return <void_ptr>self._ptr[0].handle.win32.name
     @name.setter
     def name(self, name):
-        _cname = utils.HelperInputVoidPtr(name)
-        self._ptr[0].handle.win32.name = <void*><void_ptr>_cname.cptr
+        _cyname = utils.HelperInputVoidPtr(name)
+        self._ptr[0].handle.win32.name = <void*><void_ptr>_cyname.cptr
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
-cdef class _cudaExternalSemaphoreHandleDesc_handle_u:
+cdef class anon_union2:
     """
-
     Attributes
     ----------
     fd : int
 
-    win32 : _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s
+    win32 : anon_struct6
 
-    nvSciSyncObj : void
+    nvSciSyncObj : Any
 
 
     Methods
@@ -7798,48 +8240,53 @@ cdef class _cudaExternalSemaphoreHandleDesc_handle_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreHandleDesc *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreHandleDesc *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._win32 = _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s(_ptr=<void_ptr>self._ptr)
+        self._win32 = anon_struct6(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].handle
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fd : ' + str(self.fd)]
-            str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
-            str_list += ['nvSciSyncObj : ' + hex(self.nvSciSyncObj)]
+            try:
+                str_list += ['fd : ' + str(self.fd)]
+            except ValueError:
+                str_list += ['fd : <ValueError>']
+            try:
+                str_list += ['win32 :\n' + '\n'.join(['    ' + line for line in str(self.win32).splitlines()])]
+            except ValueError:
+                str_list += ['win32 : <ValueError>']
+            try:
+                str_list += ['nvSciSyncObj : ' + hex(self.nvSciSyncObj)]
+            except ValueError:
+                str_list += ['nvSciSyncObj : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fd(self):
         return self._ptr[0].handle.fd
     @fd.setter
     def fd(self, int fd):
-        pass
         self._ptr[0].handle.fd = fd
     @property
     def win32(self):
         return self._win32
     @win32.setter
-    def win32(self, win32 not None : _cudaExternalSemaphoreHandleDesc_handle_handle_win32_s):
-        pass
-        for _attr in dir(win32):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._win32, _attr, getattr(win32, _attr))
+    def win32(self, win32 not None : anon_struct6):
+        string.memcpy(&self._ptr[0].handle.win32, <cyruntime.anon_struct6*><void_ptr>win32.getPtr(), sizeof(self._ptr[0].handle.win32))
     @property
     def nvSciSyncObj(self):
         return <void_ptr>self._ptr[0].handle.nvSciSyncObj
     @nvSciSyncObj.setter
     def nvSciSyncObj(self, nvSciSyncObj):
-        _cnvSciSyncObj = utils.HelperInputVoidPtr(nvSciSyncObj)
-        self._ptr[0].handle.nvSciSyncObj = <void*><void_ptr>_cnvSciSyncObj.cptr
+        _cynvSciSyncObj = utils.HelperInputVoidPtr(nvSciSyncObj)
+        self._ptr[0].handle.nvSciSyncObj = <void*><void_ptr>_cynvSciSyncObj.cptr
 {{endif}}
-{{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+{{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
 
 cdef class cudaExternalSemaphoreHandleDesc:
     """
@@ -7849,7 +8296,7 @@ cdef class cudaExternalSemaphoreHandleDesc:
     ----------
     type : cudaExternalSemaphoreHandleType
         Type of the handle
-    handle : _cudaExternalSemaphoreHandleDesc_handle_u
+    handle : anon_union2
 
     flags : unsigned int
         Flags reserved for the future. Must be zero.
@@ -7862,56 +8309,58 @@ cdef class cudaExternalSemaphoreHandleDesc:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cyruntime.cudaExternalSemaphoreHandleDesc *>calloc(1, sizeof(cyruntime.cudaExternalSemaphoreHandleDesc))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccudart.cudaExternalSemaphoreHandleDesc *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphoreHandleDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._handle = _cudaExternalSemaphoreHandleDesc_handle_u(_ptr=<void_ptr>self._ptr)
+        self._handle = anon_union2(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['type : ' + str(self.type)]
-            str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
+            try:
+                str_list += ['type : ' + str(self.type)]
+            except ValueError:
+                str_list += ['type : <ValueError>']
+            try:
+                str_list += ['handle :\n' + '\n'.join(['    ' + line for line in str(self.handle).splitlines()])]
+            except ValueError:
+                str_list += ['handle : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def type(self):
         return cudaExternalSemaphoreHandleType(self._ptr[0].type)
     @type.setter
     def type(self, type not None : cudaExternalSemaphoreHandleType):
-        pass
         self._ptr[0].type = type.value
     @property
     def handle(self):
         return self._handle
     @handle.setter
-    def handle(self, handle not None : _cudaExternalSemaphoreHandleDesc_handle_u):
-        pass
-        for _attr in dir(handle):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._handle, _attr, getattr(handle, _attr))
+    def handle(self, handle not None : anon_union2):
+        string.memcpy(&self._ptr[0].handle, <cyruntime.anon_union2*><void_ptr>handle.getPtr(), sizeof(self._ptr[0].handle))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_fence_s:
+cdef class anon_struct13:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -7924,35 +8373,38 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_fence_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreSignalParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreSignalParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.fence
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['value : ' + str(self.value)]
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def value(self):
         return self._ptr[0].params.fence.value
     @value.setter
     def value(self, unsigned long long value):
-        pass
         self._ptr[0].params.fence.value = value
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u:
+cdef class anon_union5:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -7964,40 +8416,46 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreSignalParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreSignalParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.nvSciSync
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence : ' + hex(self.fence)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence : ' + hex(self.fence)]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return <void_ptr>self._ptr[0].params.nvSciSync.fence
     @fence.setter
     def fence(self, fence):
-        _cfence = utils.HelperInputVoidPtr(fence)
-        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cfence.cptr
+        _cyfence = utils.HelperInputVoidPtr(fence)
+        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cyfence.cptr
     @property
     def reserved(self):
         return self._ptr[0].params.nvSciSync.reserved
     @reserved.setter
     def reserved(self, unsigned long long reserved):
-        pass
         self._ptr[0].params.nvSciSync.reserved = reserved
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s:
+cdef class anon_struct14:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -8010,39 +8468,42 @@ cdef class _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreSignalParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreSignalParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.keyedMutex
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['key : ' + str(self.key)]
+            try:
+                str_list += ['key : ' + str(self.key)]
+            except ValueError:
+                str_list += ['key : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def key(self):
         return self._ptr[0].params.keyedMutex.key
     @key.setter
     def key(self, unsigned long long key):
-        pass
         self._ptr[0].params.keyedMutex.key = key
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreSignalParams_params_s:
+cdef class anon_struct15:
     """
-
     Attributes
     ----------
-    fence : _cudaExternalSemaphoreSignalParams_params_params_fence_s
+    fence : anon_struct13
 
-    nvSciSync : _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u
+    nvSciSync : anon_union5
 
-    keyedMutex : _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s
+    keyedMutex : anon_struct14
 
     reserved : List[unsigned int]
 
@@ -8054,66 +8515,64 @@ cdef class _cudaExternalSemaphoreSignalParams_params_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreSignalParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreSignalParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._fence = _cudaExternalSemaphoreSignalParams_params_params_fence_s(_ptr=<void_ptr>self._ptr)
-        self._nvSciSync = _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u(_ptr=<void_ptr>self._ptr)
-        self._keyedMutex = _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s(_ptr=<void_ptr>self._ptr)
+        self._fence = anon_struct13(_ptr=<void_ptr>self._ptr)
+        self._nvSciSync = anon_union5(_ptr=<void_ptr>self._ptr)
+        self._keyedMutex = anon_struct14(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
-            str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
-            str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
+            except ValueError:
+                str_list += ['nvSciSync : <ValueError>']
+            try:
+                str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
+            except ValueError:
+                str_list += ['keyedMutex : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return self._fence
     @fence.setter
-    def fence(self, fence not None : _cudaExternalSemaphoreSignalParams_params_params_fence_s):
-        pass
-        for _attr in dir(fence):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._fence, _attr, getattr(fence, _attr))
+    def fence(self, fence not None : anon_struct13):
+        string.memcpy(&self._ptr[0].params.fence, <cyruntime.anon_struct13*><void_ptr>fence.getPtr(), sizeof(self._ptr[0].params.fence))
     @property
     def nvSciSync(self):
         return self._nvSciSync
     @nvSciSync.setter
-    def nvSciSync(self, nvSciSync not None : _cudaExternalSemaphoreSignalParams_params_params_nvSciSync_u):
-        pass
-        for _attr in dir(nvSciSync):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._nvSciSync, _attr, getattr(nvSciSync, _attr))
+    def nvSciSync(self, nvSciSync not None : anon_union5):
+        string.memcpy(&self._ptr[0].params.nvSciSync, <cyruntime.anon_union5*><void_ptr>nvSciSync.getPtr(), sizeof(self._ptr[0].params.nvSciSync))
     @property
     def keyedMutex(self):
         return self._keyedMutex
     @keyedMutex.setter
-    def keyedMutex(self, keyedMutex not None : _cudaExternalSemaphoreSignalParams_params_params_keyedMutex_s):
-        pass
-        for _attr in dir(keyedMutex):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._keyedMutex, _attr, getattr(keyedMutex, _attr))
+    def keyedMutex(self, keyedMutex not None : anon_struct14):
+        string.memcpy(&self._ptr[0].params.keyedMutex, <cyruntime.anon_struct14*><void_ptr>keyedMutex.getPtr(), sizeof(self._ptr[0].params.keyedMutex))
     @property
     def reserved(self):
         return self._ptr[0].params.reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].params.reserved = reserved
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
 
 cdef class cudaExternalSemaphoreSignalParams:
     """
@@ -8121,7 +8580,7 @@ cdef class cudaExternalSemaphoreSignalParams:
 
     Attributes
     ----------
-    params : _cudaExternalSemaphoreSignalParams_params_s
+    params : anon_struct15
 
     flags : unsigned int
         Only when cudaExternalSemaphoreSignalParams is used to signal a
@@ -8145,9 +8604,9 @@ cdef class cudaExternalSemaphoreSignalParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalSemaphoreSignalParams *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphoreSignalParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._params = _cudaExternalSemaphoreSignalParams_params_s(_ptr=<void_ptr>self._ptr)
+        self._params = anon_struct15(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -8155,44 +8614,44 @@ cdef class cudaExternalSemaphoreSignalParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
+            except ValueError:
+                str_list += ['params : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def params(self):
         return self._params
     @params.setter
-    def params(self, params not None : _cudaExternalSemaphoreSignalParams_params_s):
-        pass
-        for _attr in dir(params):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._params, _attr, getattr(params, _attr))
+    def params(self, params not None : anon_struct15):
+        string.memcpy(&self._ptr[0].params, <cyruntime.anon_struct15*><void_ptr>params.getPtr(), sizeof(self._ptr[0].params))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_fence_s:
+cdef class anon_struct16:
     """
-
     Attributes
     ----------
     value : unsigned long long
@@ -8205,35 +8664,38 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_fence_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreWaitParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreWaitParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.fence
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['value : ' + str(self.value)]
+            try:
+                str_list += ['value : ' + str(self.value)]
+            except ValueError:
+                str_list += ['value : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def value(self):
         return self._ptr[0].params.fence.value
     @value.setter
     def value(self, unsigned long long value):
-        pass
         self._ptr[0].params.fence.value = value
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u:
+cdef class anon_union6:
     """
-
     Attributes
     ----------
-    fence : void
+    fence : Any
 
     reserved : unsigned long long
 
@@ -8245,40 +8707,46 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreWaitParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreWaitParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.nvSciSync
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence : ' + hex(self.fence)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence : ' + hex(self.fence)]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return <void_ptr>self._ptr[0].params.nvSciSync.fence
     @fence.setter
     def fence(self, fence):
-        _cfence = utils.HelperInputVoidPtr(fence)
-        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cfence.cptr
+        _cyfence = utils.HelperInputVoidPtr(fence)
+        self._ptr[0].params.nvSciSync.fence = <void*><void_ptr>_cyfence.cptr
     @property
     def reserved(self):
         return self._ptr[0].params.nvSciSync.reserved
     @reserved.setter
     def reserved(self, unsigned long long reserved):
-        pass
         self._ptr[0].params.nvSciSync.reserved = reserved
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s:
+cdef class anon_struct17:
     """
-
     Attributes
     ----------
     key : unsigned long long
@@ -8293,47 +8761,52 @@ cdef class _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreWaitParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreWaitParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params.keyedMutex
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['key : ' + str(self.key)]
-            str_list += ['timeoutMs : ' + str(self.timeoutMs)]
+            try:
+                str_list += ['key : ' + str(self.key)]
+            except ValueError:
+                str_list += ['key : <ValueError>']
+            try:
+                str_list += ['timeoutMs : ' + str(self.timeoutMs)]
+            except ValueError:
+                str_list += ['timeoutMs : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def key(self):
         return self._ptr[0].params.keyedMutex.key
     @key.setter
     def key(self, unsigned long long key):
-        pass
         self._ptr[0].params.keyedMutex.key = key
     @property
     def timeoutMs(self):
         return self._ptr[0].params.keyedMutex.timeoutMs
     @timeoutMs.setter
     def timeoutMs(self, unsigned int timeoutMs):
-        pass
         self._ptr[0].params.keyedMutex.timeoutMs = timeoutMs
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
-cdef class _cudaExternalSemaphoreWaitParams_params_s:
+cdef class anon_struct18:
     """
-
     Attributes
     ----------
-    fence : _cudaExternalSemaphoreWaitParams_params_params_fence_s
+    fence : anon_struct16
 
-    nvSciSync : _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u
+    nvSciSync : anon_union6
 
-    keyedMutex : _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s
+    keyedMutex : anon_struct17
 
     reserved : List[unsigned int]
 
@@ -8345,66 +8818,64 @@ cdef class _cudaExternalSemaphoreWaitParams_params_s:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaExternalSemaphoreWaitParams *>_ptr
+        self._ptr = <cyruntime.cudaExternalSemaphoreWaitParams *>_ptr
+
     def __init__(self, void_ptr _ptr):
-        self._fence = _cudaExternalSemaphoreWaitParams_params_params_fence_s(_ptr=<void_ptr>self._ptr)
-        self._nvSciSync = _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u(_ptr=<void_ptr>self._ptr)
-        self._keyedMutex = _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s(_ptr=<void_ptr>self._ptr)
+        self._fence = anon_struct16(_ptr=<void_ptr>self._ptr)
+        self._nvSciSync = anon_union6(_ptr=<void_ptr>self._ptr)
+        self._keyedMutex = anon_struct17(_ptr=<void_ptr>self._ptr)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].params
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
-            str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
-            str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['fence :\n' + '\n'.join(['    ' + line for line in str(self.fence).splitlines()])]
+            except ValueError:
+                str_list += ['fence : <ValueError>']
+            try:
+                str_list += ['nvSciSync :\n' + '\n'.join(['    ' + line for line in str(self.nvSciSync).splitlines()])]
+            except ValueError:
+                str_list += ['nvSciSync : <ValueError>']
+            try:
+                str_list += ['keyedMutex :\n' + '\n'.join(['    ' + line for line in str(self.keyedMutex).splitlines()])]
+            except ValueError:
+                str_list += ['keyedMutex : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def fence(self):
         return self._fence
     @fence.setter
-    def fence(self, fence not None : _cudaExternalSemaphoreWaitParams_params_params_fence_s):
-        pass
-        for _attr in dir(fence):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._fence, _attr, getattr(fence, _attr))
+    def fence(self, fence not None : anon_struct16):
+        string.memcpy(&self._ptr[0].params.fence, <cyruntime.anon_struct16*><void_ptr>fence.getPtr(), sizeof(self._ptr[0].params.fence))
     @property
     def nvSciSync(self):
         return self._nvSciSync
     @nvSciSync.setter
-    def nvSciSync(self, nvSciSync not None : _cudaExternalSemaphoreWaitParams_params_params_nvSciSync_u):
-        pass
-        for _attr in dir(nvSciSync):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._nvSciSync, _attr, getattr(nvSciSync, _attr))
+    def nvSciSync(self, nvSciSync not None : anon_union6):
+        string.memcpy(&self._ptr[0].params.nvSciSync, <cyruntime.anon_union6*><void_ptr>nvSciSync.getPtr(), sizeof(self._ptr[0].params.nvSciSync))
     @property
     def keyedMutex(self):
         return self._keyedMutex
     @keyedMutex.setter
-    def keyedMutex(self, keyedMutex not None : _cudaExternalSemaphoreWaitParams_params_params_keyedMutex_s):
-        pass
-        for _attr in dir(keyedMutex):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._keyedMutex, _attr, getattr(keyedMutex, _attr))
+    def keyedMutex(self, keyedMutex not None : anon_struct17):
+        string.memcpy(&self._ptr[0].params.keyedMutex, <cyruntime.anon_struct17*><void_ptr>keyedMutex.getPtr(), sizeof(self._ptr[0].params.keyedMutex))
     @property
     def reserved(self):
         return self._ptr[0].params.reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].params.reserved = reserved
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
 
 cdef class cudaExternalSemaphoreWaitParams:
     """
@@ -8412,7 +8883,7 @@ cdef class cudaExternalSemaphoreWaitParams:
 
     Attributes
     ----------
-    params : _cudaExternalSemaphoreWaitParams_params_s
+    params : anon_struct18
 
     flags : unsigned int
         Only when cudaExternalSemaphoreSignalParams is used to signal a
@@ -8436,9 +8907,9 @@ cdef class cudaExternalSemaphoreWaitParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalSemaphoreWaitParams *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphoreWaitParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._params = _cudaExternalSemaphoreWaitParams_params_s(_ptr=<void_ptr>self._ptr)
+        self._params = anon_struct18(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -8446,40 +8917,41 @@ cdef class cudaExternalSemaphoreWaitParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['params :\n' + '\n'.join(['    ' + line for line in str(self.params).splitlines()])]
+            except ValueError:
+                str_list += ['params : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def params(self):
         return self._params
     @params.setter
-    def params(self, params not None : _cudaExternalSemaphoreWaitParams_params_s):
-        pass
-        for _attr in dir(params):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._params, _attr, getattr(params, _attr))
+    def params(self, params not None : anon_struct18):
+        string.memcpy(&self._ptr[0].params, <cyruntime.anon_struct18*><void_ptr>params.getPtr(), sizeof(self._ptr[0].params))
     @property
     def flags(self):
         return self._ptr[0].flags
     @flags.setter
     def flags(self, unsigned int flags):
-        pass
         self._ptr[0].flags = flags
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if 'cudaKernelNodeParams' in found_types}}
+{{if 'struct cudaKernelNodeParams' in found_types}}
 
 cdef class cudaKernelNodeParams:
     """
@@ -8510,7 +8982,7 @@ cdef class cudaKernelNodeParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaKernelNodeParams *>_ptr
+            self._ptr = <cyruntime.cudaKernelNodeParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._gridDim = dim3(_ptr=<void_ptr>&self._ptr[0].gridDim)
         self._blockDim = dim3(_ptr=<void_ptr>&self._ptr[0].blockDim)
@@ -8521,59 +8993,65 @@ cdef class cudaKernelNodeParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['func : ' + hex(self.func)]
-            str_list += ['gridDim :\n' + '\n'.join(['    ' + line for line in str(self.gridDim).splitlines()])]
-            str_list += ['blockDim :\n' + '\n'.join(['    ' + line for line in str(self.blockDim).splitlines()])]
-            str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
-            str_list += ['kernelParams : ' + str(self.kernelParams)]
-            str_list += ['extra : ' + str(self.extra)]
+            try:
+                str_list += ['func : ' + hex(self.func)]
+            except ValueError:
+                str_list += ['func : <ValueError>']
+            try:
+                str_list += ['gridDim :\n' + '\n'.join(['    ' + line for line in str(self.gridDim).splitlines()])]
+            except ValueError:
+                str_list += ['gridDim : <ValueError>']
+            try:
+                str_list += ['blockDim :\n' + '\n'.join(['    ' + line for line in str(self.blockDim).splitlines()])]
+            except ValueError:
+                str_list += ['blockDim : <ValueError>']
+            try:
+                str_list += ['sharedMemBytes : ' + str(self.sharedMemBytes)]
+            except ValueError:
+                str_list += ['sharedMemBytes : <ValueError>']
+            try:
+                str_list += ['kernelParams : ' + str(self.kernelParams)]
+            except ValueError:
+                str_list += ['kernelParams : <ValueError>']
+            try:
+                str_list += ['extra : ' + str(self.extra)]
+            except ValueError:
+                str_list += ['extra : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def func(self):
         return <void_ptr>self._ptr[0].func
     @func.setter
     def func(self, func):
-        _cfunc = utils.HelperInputVoidPtr(func)
-        self._ptr[0].func = <void*><void_ptr>_cfunc.cptr
+        _cyfunc = utils.HelperInputVoidPtr(func)
+        self._ptr[0].func = <void*><void_ptr>_cyfunc.cptr
     @property
     def gridDim(self):
         return self._gridDim
     @gridDim.setter
     def gridDim(self, gridDim not None : dim3):
-        pass
-        for _attr in dir(gridDim):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._gridDim, _attr, getattr(gridDim, _attr))
+        string.memcpy(&self._ptr[0].gridDim, <cyruntime.dim3*><void_ptr>gridDim.getPtr(), sizeof(self._ptr[0].gridDim))
     @property
     def blockDim(self):
         return self._blockDim
     @blockDim.setter
     def blockDim(self, blockDim not None : dim3):
-        pass
-        for _attr in dir(blockDim):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._blockDim, _attr, getattr(blockDim, _attr))
+        string.memcpy(&self._ptr[0].blockDim, <cyruntime.dim3*><void_ptr>blockDim.getPtr(), sizeof(self._ptr[0].blockDim))
     @property
     def sharedMemBytes(self):
         return self._ptr[0].sharedMemBytes
     @sharedMemBytes.setter
     def sharedMemBytes(self, unsigned int sharedMemBytes):
-        pass
         self._ptr[0].sharedMemBytes = sharedMemBytes
     @property
     def kernelParams(self):
         return <void_ptr>self._ptr[0].kernelParams
     @kernelParams.setter
     def kernelParams(self, kernelParams):
-        self._ckernelParams = utils.HelperKernelParams(kernelParams)
-        self._ptr[0].kernelParams = <void**><void_ptr>self._ckernelParams.ckernelParams
+        self._cykernelParams = utils.HelperKernelParams(kernelParams)
+        self._ptr[0].kernelParams = <void**><void_ptr>self._cykernelParams.ckernelParams
     @property
     def extra(self):
         return <void_ptr>self._ptr[0].extra
@@ -8581,7 +9059,7 @@ cdef class cudaKernelNodeParams:
     def extra(self, void_ptr extra):
         self._ptr[0].extra = <void**>extra
 {{endif}}
-{{if 'cudaExternalSemaphoreSignalNodeParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreSignalNodeParams' in found_types}}
 
 cdef class cudaExternalSemaphoreSignalNodeParams:
     """
@@ -8607,7 +9085,7 @@ cdef class cudaExternalSemaphoreSignalNodeParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalSemaphoreSignalNodeParams *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphoreSignalNodeParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -8620,16 +9098,24 @@ cdef class cudaExternalSemaphoreSignalNodeParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['extSemArray : ' + str(self.extSemArray)]
-            str_list += ['paramsArray : ' + str(self.paramsArray)]
-            str_list += ['numExtSems : ' + str(self.numExtSems)]
+            try:
+                str_list += ['extSemArray : ' + str(self.extSemArray)]
+            except ValueError:
+                str_list += ['extSemArray : <ValueError>']
+            try:
+                str_list += ['paramsArray : ' + str(self.paramsArray)]
+            except ValueError:
+                str_list += ['paramsArray : <ValueError>']
+            try:
+                str_list += ['numExtSems : ' + str(self.numExtSems)]
+            except ValueError:
+                str_list += ['numExtSems : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def extSemArray(self):
-        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(ccudart.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)]
+        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)]
         return [cudaExternalSemaphore_t(_ptr=arr) for arr in arrs]
     @extSemArray.setter
     def extSemArray(self, val):
@@ -8640,16 +9126,17 @@ cdef class cudaExternalSemaphoreSignalNodeParams:
         else:
             if self._extSemArray_length != <size_t>len(val):
                 free(self._extSemArray)
-                self._extSemArray = <ccudart.cudaExternalSemaphore_t*> calloc(len(val), sizeof(ccudart.cudaExternalSemaphore_t))
+                self._extSemArray = <cyruntime.cudaExternalSemaphore_t*> calloc(len(val), sizeof(cyruntime.cudaExternalSemaphore_t))
                 if self._extSemArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphore_t)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphore_t)))
                 self._extSemArray_length = <size_t>len(val)
                 self._ptr[0].extSemArray = self._extSemArray
             for idx in range(len(val)):
                 self._extSemArray[idx] = (<cudaExternalSemaphore_t>val[idx])._ptr[0]
+
     @property
     def paramsArray(self):
-        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(ccudart.cudaExternalSemaphoreSignalParams) for x in range(self._paramsArray_length)]
+        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreSignalParams) for x in range(self._paramsArray_length)]
         return [cudaExternalSemaphoreSignalParams(_ptr=arr) for arr in arrs]
     @paramsArray.setter
     def paramsArray(self, val):
@@ -8660,22 +9147,22 @@ cdef class cudaExternalSemaphoreSignalNodeParams:
         else:
             if self._paramsArray_length != <size_t>len(val):
                 free(self._paramsArray)
-                self._paramsArray = <ccudart.cudaExternalSemaphoreSignalParams*> calloc(len(val), sizeof(ccudart.cudaExternalSemaphoreSignalParams))
+                self._paramsArray = <cyruntime.cudaExternalSemaphoreSignalParams*> calloc(len(val), sizeof(cyruntime.cudaExternalSemaphoreSignalParams))
                 if self._paramsArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphoreSignalParams)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphoreSignalParams)))
                 self._paramsArray_length = <size_t>len(val)
                 self._ptr[0].paramsArray = self._paramsArray
             for idx in range(len(val)):
-                memcpy(&self._paramsArray[idx], (<cudaExternalSemaphoreSignalParams>val[idx])._ptr, sizeof(ccudart.cudaExternalSemaphoreSignalParams))
+                string.memcpy(&self._paramsArray[idx], (<cudaExternalSemaphoreSignalParams>val[idx])._ptr, sizeof(cyruntime.cudaExternalSemaphoreSignalParams))
+
     @property
     def numExtSems(self):
         return self._ptr[0].numExtSems
     @numExtSems.setter
     def numExtSems(self, unsigned int numExtSems):
-        pass
         self._ptr[0].numExtSems = numExtSems
 {{endif}}
-{{if 'cudaExternalSemaphoreWaitNodeParams' in found_types}}
+{{if 'struct cudaExternalSemaphoreWaitNodeParams' in found_types}}
 
 cdef class cudaExternalSemaphoreWaitNodeParams:
     """
@@ -8701,7 +9188,7 @@ cdef class cudaExternalSemaphoreWaitNodeParams:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaExternalSemaphoreWaitNodeParams *>_ptr
+            self._ptr = <cyruntime.cudaExternalSemaphoreWaitNodeParams *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -8714,16 +9201,24 @@ cdef class cudaExternalSemaphoreWaitNodeParams:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['extSemArray : ' + str(self.extSemArray)]
-            str_list += ['paramsArray : ' + str(self.paramsArray)]
-            str_list += ['numExtSems : ' + str(self.numExtSems)]
+            try:
+                str_list += ['extSemArray : ' + str(self.extSemArray)]
+            except ValueError:
+                str_list += ['extSemArray : <ValueError>']
+            try:
+                str_list += ['paramsArray : ' + str(self.paramsArray)]
+            except ValueError:
+                str_list += ['paramsArray : <ValueError>']
+            try:
+                str_list += ['numExtSems : ' + str(self.numExtSems)]
+            except ValueError:
+                str_list += ['numExtSems : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def extSemArray(self):
-        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(ccudart.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)]
+        arrs = [<void_ptr>self._ptr[0].extSemArray + x*sizeof(cyruntime.cudaExternalSemaphore_t) for x in range(self._extSemArray_length)]
         return [cudaExternalSemaphore_t(_ptr=arr) for arr in arrs]
     @extSemArray.setter
     def extSemArray(self, val):
@@ -8734,16 +9229,17 @@ cdef class cudaExternalSemaphoreWaitNodeParams:
         else:
             if self._extSemArray_length != <size_t>len(val):
                 free(self._extSemArray)
-                self._extSemArray = <ccudart.cudaExternalSemaphore_t*> calloc(len(val), sizeof(ccudart.cudaExternalSemaphore_t))
+                self._extSemArray = <cyruntime.cudaExternalSemaphore_t*> calloc(len(val), sizeof(cyruntime.cudaExternalSemaphore_t))
                 if self._extSemArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphore_t)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphore_t)))
                 self._extSemArray_length = <size_t>len(val)
                 self._ptr[0].extSemArray = self._extSemArray
             for idx in range(len(val)):
                 self._extSemArray[idx] = (<cudaExternalSemaphore_t>val[idx])._ptr[0]
+
     @property
     def paramsArray(self):
-        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(ccudart.cudaExternalSemaphoreWaitParams) for x in range(self._paramsArray_length)]
+        arrs = [<void_ptr>self._ptr[0].paramsArray + x*sizeof(cyruntime.cudaExternalSemaphoreWaitParams) for x in range(self._paramsArray_length)]
         return [cudaExternalSemaphoreWaitParams(_ptr=arr) for arr in arrs]
     @paramsArray.setter
     def paramsArray(self, val):
@@ -8754,26 +9250,25 @@ cdef class cudaExternalSemaphoreWaitNodeParams:
         else:
             if self._paramsArray_length != <size_t>len(val):
                 free(self._paramsArray)
-                self._paramsArray = <ccudart.cudaExternalSemaphoreWaitParams*> calloc(len(val), sizeof(ccudart.cudaExternalSemaphoreWaitParams))
+                self._paramsArray = <cyruntime.cudaExternalSemaphoreWaitParams*> calloc(len(val), sizeof(cyruntime.cudaExternalSemaphoreWaitParams))
                 if self._paramsArray is NULL:
-                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphoreWaitParams)))
+                    raise MemoryError('Failed to allocate length x size memory: ' + str(len(val)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphoreWaitParams)))
                 self._paramsArray_length = <size_t>len(val)
                 self._ptr[0].paramsArray = self._paramsArray
             for idx in range(len(val)):
-                memcpy(&self._paramsArray[idx], (<cudaExternalSemaphoreWaitParams>val[idx])._ptr, sizeof(ccudart.cudaExternalSemaphoreWaitParams))
+                string.memcpy(&self._paramsArray[idx], (<cudaExternalSemaphoreWaitParams>val[idx])._ptr, sizeof(cyruntime.cudaExternalSemaphoreWaitParams))
+
     @property
     def numExtSems(self):
         return self._ptr[0].numExtSems
     @numExtSems.setter
     def numExtSems(self, unsigned int numExtSems):
-        pass
         self._ptr[0].numExtSems = numExtSems
 {{endif}}
-{{if 'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s' in found_types}}
+{{if 'union cudaLaunchAttributeValue' in found_types}}
 
-cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s:
+cdef class anon_struct19:
     """
-
     Attributes
     ----------
     x : unsigned int
@@ -8790,48 +9285,55 @@ cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttribut
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaLaunchAttributeValue *>_ptr
+        self._ptr = <cyruntime.cudaLaunchAttributeValue *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].clusterDim
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['x : ' + str(self.x)]
-            str_list += ['y : ' + str(self.y)]
-            str_list += ['z : ' + str(self.z)]
+            try:
+                str_list += ['x : ' + str(self.x)]
+            except ValueError:
+                str_list += ['x : <ValueError>']
+            try:
+                str_list += ['y : ' + str(self.y)]
+            except ValueError:
+                str_list += ['y : <ValueError>']
+            try:
+                str_list += ['z : ' + str(self.z)]
+            except ValueError:
+                str_list += ['z : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def x(self):
         return self._ptr[0].clusterDim.x
     @x.setter
     def x(self, unsigned int x):
-        pass
         self._ptr[0].clusterDim.x = x
     @property
     def y(self):
         return self._ptr[0].clusterDim.y
     @y.setter
     def y(self, unsigned int y):
-        pass
         self._ptr[0].clusterDim.y = y
     @property
     def z(self):
         return self._ptr[0].clusterDim.z
     @z.setter
     def z(self, unsigned int z):
-        pass
         self._ptr[0].clusterDim.z = z
 {{endif}}
-{{if 'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s' in found_types}}
+{{if 'union cudaLaunchAttributeValue' in found_types}}
 
-cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s:
+cdef class anon_struct20:
     """
-
     Attributes
     ----------
     event : cudaEvent_t
@@ -8848,49 +9350,58 @@ cdef class _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttribut
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaLaunchAttributeValue *>_ptr
+        self._ptr = <cyruntime.cudaLaunchAttributeValue *>_ptr
+
     def __init__(self, void_ptr _ptr):
         self._event = cudaEvent_t(_ptr=<void_ptr>&self._ptr[0].programmaticEvent.event)
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].programmaticEvent
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['event : ' + str(self.event)]
-            str_list += ['flags : ' + str(self.flags)]
-            str_list += ['triggerAtBlockStart : ' + str(self.triggerAtBlockStart)]
+            try:
+                str_list += ['event : ' + str(self.event)]
+            except ValueError:
+                str_list += ['event : <ValueError>']
+            try:
+                str_list += ['flags : ' + str(self.flags)]
+            except ValueError:
+                str_list += ['flags : <ValueError>']
+            try:
+                str_list += ['triggerAtBlockStart : ' + str(self.triggerAtBlockStart)]
+            except ValueError:
+                str_list += ['triggerAtBlockStart : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def event(self):
         return self._event
     @event.setter
     def event(self, event):
-        cdef ccudart.cudaEvent_t cevent
+        cdef cyruntime.cudaEvent_t cyevent
         if event is None:
-            cevent = <ccudart.cudaEvent_t><void_ptr>0
-        elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+            cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+        elif isinstance(event, (cudaEvent_t,driver.CUevent)):
             pevent = int(event)
-            cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+            cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
         else:
             pevent = int(cudaEvent_t(event))
-            cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-        self._event._ptr[0] = cevent
+            cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+        self._event._ptr[0] = cyevent
     @property
     def flags(self):
         return self._ptr[0].programmaticEvent.flags
     @flags.setter
     def flags(self, int flags):
-        pass
         self._ptr[0].programmaticEvent.flags = flags
     @property
     def triggerAtBlockStart(self):
         return self._ptr[0].programmaticEvent.triggerAtBlockStart
     @triggerAtBlockStart.setter
     def triggerAtBlockStart(self, int triggerAtBlockStart):
-        pass
         self._ptr[0].programmaticEvent.triggerAtBlockStart = triggerAtBlockStart
 {{endif}}
 {{if 'union cudaLaunchAttributeValue' in found_types}}
@@ -8910,13 +9421,13 @@ cdef class cudaLaunchAttributeValue:
 
     syncPolicy : cudaSynchronizationPolicy
 
-    clusterDim : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s
+    clusterDim : anon_struct19
 
     clusterSchedulingPolicyPreference : cudaClusterSchedulingPolicy
 
     programmaticStreamSerializationAllowed : int
 
-    programmaticEvent : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s
+    programmaticEvent : anon_struct20
 
     priority : int
 
@@ -8931,11 +9442,11 @@ cdef class cudaLaunchAttributeValue:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaLaunchAttributeValue *>_ptr
+            self._ptr = <cyruntime.cudaLaunchAttributeValue *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        {{if 'accessPolicyWindow' in found_unions['cudaLaunchAttributeValue']['members']}}self._accessPolicyWindow = cudaAccessPolicyWindow(_ptr=<void_ptr>&self._ptr[0].accessPolicyWindow){{endif}}
-        {{if 'clusterDim' in found_unions['cudaLaunchAttributeValue']['members']}}self._clusterDim = _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s(_ptr=<void_ptr>self._ptr){{endif}}
-        {{if 'programmaticEvent' in found_unions['cudaLaunchAttributeValue']['members']}}self._programmaticEvent = _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s(_ptr=<void_ptr>self._ptr){{endif}}
+        self._accessPolicyWindow = cudaAccessPolicyWindow(_ptr=<void_ptr>&self._ptr[0].accessPolicyWindow)
+        self._clusterDim = anon_struct19(_ptr=<void_ptr>self._ptr)
+        self._programmaticEvent = anon_struct20(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
         pass
     def getPtr(self):
@@ -8943,19 +9454,45 @@ cdef class cudaLaunchAttributeValue:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            {{if 'pad' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['pad : ' + str(self.pad)]{{endif}}
-            {{if 'accessPolicyWindow' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['accessPolicyWindow :\n' + '\n'.join(['    ' + line for line in str(self.accessPolicyWindow).splitlines()])]{{endif}}
-            {{if 'cooperative' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['cooperative : ' + str(self.cooperative)]{{endif}}
-            {{if 'syncPolicy' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['syncPolicy : ' + str(self.syncPolicy)]{{endif}}
-            {{if 'clusterDim' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['clusterDim :\n' + '\n'.join(['    ' + line for line in str(self.clusterDim).splitlines()])]{{endif}}
-            {{if 'clusterSchedulingPolicyPreference' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)]{{endif}}
-            {{if 'programmaticStreamSerializationAllowed' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['programmaticStreamSerializationAllowed : ' + str(self.programmaticStreamSerializationAllowed)]{{endif}}
-            {{if 'programmaticEvent' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['programmaticEvent :\n' + '\n'.join(['    ' + line for line in str(self.programmaticEvent).splitlines()])]{{endif}}
-            {{if 'priority' in found_unions['cudaLaunchAttributeValue']['members']}}str_list += ['priority : ' + str(self.priority)]{{endif}}
+            try:
+                str_list += ['pad : ' + str(self.pad)]
+            except ValueError:
+                str_list += ['pad : <ValueError>']
+            try:
+                str_list += ['accessPolicyWindow :\n' + '\n'.join(['    ' + line for line in str(self.accessPolicyWindow).splitlines()])]
+            except ValueError:
+                str_list += ['accessPolicyWindow : <ValueError>']
+            try:
+                str_list += ['cooperative : ' + str(self.cooperative)]
+            except ValueError:
+                str_list += ['cooperative : <ValueError>']
+            try:
+                str_list += ['syncPolicy : ' + str(self.syncPolicy)]
+            except ValueError:
+                str_list += ['syncPolicy : <ValueError>']
+            try:
+                str_list += ['clusterDim :\n' + '\n'.join(['    ' + line for line in str(self.clusterDim).splitlines()])]
+            except ValueError:
+                str_list += ['clusterDim : <ValueError>']
+            try:
+                str_list += ['clusterSchedulingPolicyPreference : ' + str(self.clusterSchedulingPolicyPreference)]
+            except ValueError:
+                str_list += ['clusterSchedulingPolicyPreference : <ValueError>']
+            try:
+                str_list += ['programmaticStreamSerializationAllowed : ' + str(self.programmaticStreamSerializationAllowed)]
+            except ValueError:
+                str_list += ['programmaticStreamSerializationAllowed : <ValueError>']
+            try:
+                str_list += ['programmaticEvent :\n' + '\n'.join(['    ' + line for line in str(self.programmaticEvent).splitlines()])]
+            except ValueError:
+                str_list += ['programmaticEvent : <ValueError>']
+            try:
+                str_list += ['priority : ' + str(self.priority)]
+            except ValueError:
+                str_list += ['priority : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-    {{if 'pad' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def pad(self):
         return PyBytes_FromStringAndSize(self._ptr[0].pad, 64)
@@ -8973,85 +9510,56 @@ cdef class cudaLaunchAttributeValue:
                 if b > 127 and b < 256:
                     b = b - 256
                 self._ptr[0].pad[i] = b
-    {{endif}}
-    {{if 'accessPolicyWindow' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def accessPolicyWindow(self):
         return self._accessPolicyWindow
     @accessPolicyWindow.setter
     def accessPolicyWindow(self, accessPolicyWindow not None : cudaAccessPolicyWindow):
-        for _attr in dir(accessPolicyWindow):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._accessPolicyWindow, _attr, getattr(accessPolicyWindow, _attr))
-    {{endif}}
-    {{if 'cooperative' in found_unions['cudaLaunchAttributeValue']['members']}}
+        string.memcpy(&self._ptr[0].accessPolicyWindow, <cyruntime.cudaAccessPolicyWindow*><void_ptr>accessPolicyWindow.getPtr(), sizeof(self._ptr[0].accessPolicyWindow))
     @property
     def cooperative(self):
         return self._ptr[0].cooperative
     @cooperative.setter
     def cooperative(self, int cooperative):
         self._ptr[0].cooperative = cooperative
-    {{endif}}
-    {{if 'syncPolicy' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def syncPolicy(self):
         return cudaSynchronizationPolicy(self._ptr[0].syncPolicy)
     @syncPolicy.setter
     def syncPolicy(self, syncPolicy not None : cudaSynchronizationPolicy):
         self._ptr[0].syncPolicy = syncPolicy.value
-    {{endif}}
-    {{if 'clusterDim' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def clusterDim(self):
         return self._clusterDim
     @clusterDim.setter
-    def clusterDim(self, clusterDim not None : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s):
-        for _attr in dir(clusterDim):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._clusterDim, _attr, getattr(clusterDim, _attr))
-    {{endif}}
-    {{if 'clusterSchedulingPolicyPreference' in found_unions['cudaLaunchAttributeValue']['members']}}
+    def clusterDim(self, clusterDim not None : anon_struct19):
+        string.memcpy(&self._ptr[0].clusterDim, <cyruntime.anon_struct19*><void_ptr>clusterDim.getPtr(), sizeof(self._ptr[0].clusterDim))
     @property
     def clusterSchedulingPolicyPreference(self):
         return cudaClusterSchedulingPolicy(self._ptr[0].clusterSchedulingPolicyPreference)
     @clusterSchedulingPolicyPreference.setter
     def clusterSchedulingPolicyPreference(self, clusterSchedulingPolicyPreference not None : cudaClusterSchedulingPolicy):
         self._ptr[0].clusterSchedulingPolicyPreference = clusterSchedulingPolicyPreference.value
-    {{endif}}
-    {{if 'programmaticStreamSerializationAllowed' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def programmaticStreamSerializationAllowed(self):
         return self._ptr[0].programmaticStreamSerializationAllowed
     @programmaticStreamSerializationAllowed.setter
     def programmaticStreamSerializationAllowed(self, int programmaticStreamSerializationAllowed):
         self._ptr[0].programmaticStreamSerializationAllowed = programmaticStreamSerializationAllowed
-    {{endif}}
-    {{if 'programmaticEvent' in found_unions['cudaLaunchAttributeValue']['members']}}
     @property
     def programmaticEvent(self):
         return self._programmaticEvent
     @programmaticEvent.setter
-    def programmaticEvent(self, programmaticEvent not None : _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s):
-        for _attr in dir(programmaticEvent):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._programmaticEvent, _attr, getattr(programmaticEvent, _attr))
-    {{endif}}
-    {{if 'priority' in found_unions['cudaLaunchAttributeValue']['members']}}
+    def programmaticEvent(self, programmaticEvent not None : anon_struct20):
+        string.memcpy(&self._ptr[0].programmaticEvent, <cyruntime.anon_struct20*><void_ptr>programmaticEvent.getPtr(), sizeof(self._ptr[0].programmaticEvent))
     @property
     def priority(self):
         return self._ptr[0].priority
     @priority.setter
     def priority(self, int priority):
         self._ptr[0].priority = priority
-    {{endif}}
 {{endif}}
-{{if 'cudaLaunchAttribute_st' in found_types}}
+{{if 'struct cudaLaunchAttribute_st' in found_types}}
 
 cdef class cudaLaunchAttribute_st:
     """
@@ -9074,7 +9582,7 @@ cdef class cudaLaunchAttribute_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaLaunchAttribute_st *>_ptr
+            self._ptr = <cyruntime.cudaLaunchAttribute_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._val = cudaLaunchAttributeValue(_ptr=<void_ptr>&self._ptr[0].val)
     def __dealloc__(self):
@@ -9084,32 +9592,31 @@ cdef class cudaLaunchAttribute_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['id : ' + str(self.id)]
-            str_list += ['val :\n' + '\n'.join(['    ' + line for line in str(self.val).splitlines()])]
+            try:
+                str_list += ['id : ' + str(self.id)]
+            except ValueError:
+                str_list += ['id : <ValueError>']
+            try:
+                str_list += ['val :\n' + '\n'.join(['    ' + line for line in str(self.val).splitlines()])]
+            except ValueError:
+                str_list += ['val : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def id(self):
         return cudaLaunchAttributeID(self._ptr[0].id)
     @id.setter
     def id(self, id not None : cudaLaunchAttributeID):
-        pass
         self._ptr[0].id = id.value
     @property
     def val(self):
         return self._val
     @val.setter
     def val(self, val not None : cudaLaunchAttributeValue):
-        pass
-        for _attr in dir(val):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._val, _attr, getattr(val, _attr))
+        string.memcpy(&self._ptr[0].val, <cyruntime.cudaLaunchAttributeValue*><void_ptr>val.getPtr(), sizeof(self._ptr[0].val))
 {{endif}}
-{{if 'cudaTextureDesc' in found_types}}
+{{if 'struct cudaTextureDesc' in found_types}}
 
 cdef class cudaTextureDesc:
     """
@@ -9152,7 +9659,7 @@ cdef class cudaTextureDesc:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaTextureDesc *>_ptr
+            self._ptr = <cyruntime.cudaTextureDesc *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9162,22 +9669,57 @@ cdef class cudaTextureDesc:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['addressMode : ' + str(self.addressMode)]
-            str_list += ['filterMode : ' + str(self.filterMode)]
-            str_list += ['readMode : ' + str(self.readMode)]
-            str_list += ['sRGB : ' + str(self.sRGB)]
-            str_list += ['borderColor : ' + str(self.borderColor)]
-            str_list += ['normalizedCoords : ' + str(self.normalizedCoords)]
-            str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
-            str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
-            str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
-            str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
-            str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
-            str_list += ['disableTrilinearOptimization : ' + str(self.disableTrilinearOptimization)]
+            try:
+                str_list += ['addressMode : ' + str(self.addressMode)]
+            except ValueError:
+                str_list += ['addressMode : <ValueError>']
+            try:
+                str_list += ['filterMode : ' + str(self.filterMode)]
+            except ValueError:
+                str_list += ['filterMode : <ValueError>']
+            try:
+                str_list += ['readMode : ' + str(self.readMode)]
+            except ValueError:
+                str_list += ['readMode : <ValueError>']
+            try:
+                str_list += ['sRGB : ' + str(self.sRGB)]
+            except ValueError:
+                str_list += ['sRGB : <ValueError>']
+            try:
+                str_list += ['borderColor : ' + str(self.borderColor)]
+            except ValueError:
+                str_list += ['borderColor : <ValueError>']
+            try:
+                str_list += ['normalizedCoords : ' + str(self.normalizedCoords)]
+            except ValueError:
+                str_list += ['normalizedCoords : <ValueError>']
+            try:
+                str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
+            except ValueError:
+                str_list += ['maxAnisotropy : <ValueError>']
+            try:
+                str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
+            except ValueError:
+                str_list += ['mipmapFilterMode : <ValueError>']
+            try:
+                str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
+            except ValueError:
+                str_list += ['mipmapLevelBias : <ValueError>']
+            try:
+                str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['minMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['maxMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['disableTrilinearOptimization : ' + str(self.disableTrilinearOptimization)]
+            except ValueError:
+                str_list += ['disableTrilinearOptimization : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def addressMode(self):
         return [cudaTextureAddressMode(_x) for _x in list(self._ptr[0].addressMode)]
@@ -9189,84 +9731,72 @@ cdef class cudaTextureDesc:
         return cudaTextureFilterMode(self._ptr[0].filterMode)
     @filterMode.setter
     def filterMode(self, filterMode not None : cudaTextureFilterMode):
-        pass
         self._ptr[0].filterMode = filterMode.value
     @property
     def readMode(self):
         return cudaTextureReadMode(self._ptr[0].readMode)
     @readMode.setter
     def readMode(self, readMode not None : cudaTextureReadMode):
-        pass
         self._ptr[0].readMode = readMode.value
     @property
     def sRGB(self):
         return self._ptr[0].sRGB
     @sRGB.setter
     def sRGB(self, int sRGB):
-        pass
         self._ptr[0].sRGB = sRGB
     @property
     def borderColor(self):
         return self._ptr[0].borderColor
     @borderColor.setter
     def borderColor(self, borderColor):
-        pass
         self._ptr[0].borderColor = borderColor
     @property
     def normalizedCoords(self):
         return self._ptr[0].normalizedCoords
     @normalizedCoords.setter
     def normalizedCoords(self, int normalizedCoords):
-        pass
         self._ptr[0].normalizedCoords = normalizedCoords
     @property
     def maxAnisotropy(self):
         return self._ptr[0].maxAnisotropy
     @maxAnisotropy.setter
     def maxAnisotropy(self, unsigned int maxAnisotropy):
-        pass
         self._ptr[0].maxAnisotropy = maxAnisotropy
     @property
     def mipmapFilterMode(self):
         return cudaTextureFilterMode(self._ptr[0].mipmapFilterMode)
     @mipmapFilterMode.setter
     def mipmapFilterMode(self, mipmapFilterMode not None : cudaTextureFilterMode):
-        pass
         self._ptr[0].mipmapFilterMode = mipmapFilterMode.value
     @property
     def mipmapLevelBias(self):
         return self._ptr[0].mipmapLevelBias
     @mipmapLevelBias.setter
     def mipmapLevelBias(self, float mipmapLevelBias):
-        pass
         self._ptr[0].mipmapLevelBias = mipmapLevelBias
     @property
     def minMipmapLevelClamp(self):
         return self._ptr[0].minMipmapLevelClamp
     @minMipmapLevelClamp.setter
     def minMipmapLevelClamp(self, float minMipmapLevelClamp):
-        pass
         self._ptr[0].minMipmapLevelClamp = minMipmapLevelClamp
     @property
     def maxMipmapLevelClamp(self):
         return self._ptr[0].maxMipmapLevelClamp
     @maxMipmapLevelClamp.setter
     def maxMipmapLevelClamp(self, float maxMipmapLevelClamp):
-        pass
         self._ptr[0].maxMipmapLevelClamp = maxMipmapLevelClamp
     @property
     def disableTrilinearOptimization(self):
         return self._ptr[0].disableTrilinearOptimization
     @disableTrilinearOptimization.setter
     def disableTrilinearOptimization(self, int disableTrilinearOptimization):
-        pass
         self._ptr[0].disableTrilinearOptimization = disableTrilinearOptimization
 {{endif}}
-{{if 'cudaTextureDesc_v2' in found_types}}
+{{if 'struct cudaTextureDesc_v2' in found_types}}
 
 cdef class cudaTextureDesc_v2:
     """
-
     Attributes
     ----------
     addressMode : List[cudaTextureAddressMode]
@@ -9306,7 +9836,7 @@ cdef class cudaTextureDesc_v2:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaTextureDesc_v2 *>_ptr
+            self._ptr = <cyruntime.cudaTextureDesc_v2 *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         pass
     def __dealloc__(self):
@@ -9316,23 +9846,61 @@ cdef class cudaTextureDesc_v2:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['addressMode : ' + str(self.addressMode)]
-            str_list += ['filterMode : ' + str(self.filterMode)]
-            str_list += ['readMode : ' + str(self.readMode)]
-            str_list += ['sRGB : ' + str(self.sRGB)]
-            str_list += ['borderColor : ' + str(self.borderColor)]
-            str_list += ['normalizedCoords : ' + str(self.normalizedCoords)]
-            str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
-            str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
-            str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
-            str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
-            str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
-            str_list += ['disableTrilinearOptimization : ' + str(self.disableTrilinearOptimization)]
-            str_list += ['seamlessCubemap : ' + str(self.seamlessCubemap)]
+            try:
+                str_list += ['addressMode : ' + str(self.addressMode)]
+            except ValueError:
+                str_list += ['addressMode : <ValueError>']
+            try:
+                str_list += ['filterMode : ' + str(self.filterMode)]
+            except ValueError:
+                str_list += ['filterMode : <ValueError>']
+            try:
+                str_list += ['readMode : ' + str(self.readMode)]
+            except ValueError:
+                str_list += ['readMode : <ValueError>']
+            try:
+                str_list += ['sRGB : ' + str(self.sRGB)]
+            except ValueError:
+                str_list += ['sRGB : <ValueError>']
+            try:
+                str_list += ['borderColor : ' + str(self.borderColor)]
+            except ValueError:
+                str_list += ['borderColor : <ValueError>']
+            try:
+                str_list += ['normalizedCoords : ' + str(self.normalizedCoords)]
+            except ValueError:
+                str_list += ['normalizedCoords : <ValueError>']
+            try:
+                str_list += ['maxAnisotropy : ' + str(self.maxAnisotropy)]
+            except ValueError:
+                str_list += ['maxAnisotropy : <ValueError>']
+            try:
+                str_list += ['mipmapFilterMode : ' + str(self.mipmapFilterMode)]
+            except ValueError:
+                str_list += ['mipmapFilterMode : <ValueError>']
+            try:
+                str_list += ['mipmapLevelBias : ' + str(self.mipmapLevelBias)]
+            except ValueError:
+                str_list += ['mipmapLevelBias : <ValueError>']
+            try:
+                str_list += ['minMipmapLevelClamp : ' + str(self.minMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['minMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['maxMipmapLevelClamp : ' + str(self.maxMipmapLevelClamp)]
+            except ValueError:
+                str_list += ['maxMipmapLevelClamp : <ValueError>']
+            try:
+                str_list += ['disableTrilinearOptimization : ' + str(self.disableTrilinearOptimization)]
+            except ValueError:
+                str_list += ['disableTrilinearOptimization : <ValueError>']
+            try:
+                str_list += ['seamlessCubemap : ' + str(self.seamlessCubemap)]
+            except ValueError:
+                str_list += ['seamlessCubemap : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def addressMode(self):
         return [cudaTextureAddressMode(_x) for _x in list(self._ptr[0].addressMode)]
@@ -9344,87 +9912,75 @@ cdef class cudaTextureDesc_v2:
         return cudaTextureFilterMode(self._ptr[0].filterMode)
     @filterMode.setter
     def filterMode(self, filterMode not None : cudaTextureFilterMode):
-        pass
         self._ptr[0].filterMode = filterMode.value
     @property
     def readMode(self):
         return cudaTextureReadMode(self._ptr[0].readMode)
     @readMode.setter
     def readMode(self, readMode not None : cudaTextureReadMode):
-        pass
         self._ptr[0].readMode = readMode.value
     @property
     def sRGB(self):
         return self._ptr[0].sRGB
     @sRGB.setter
     def sRGB(self, int sRGB):
-        pass
         self._ptr[0].sRGB = sRGB
     @property
     def borderColor(self):
         return self._ptr[0].borderColor
     @borderColor.setter
     def borderColor(self, borderColor):
-        pass
         self._ptr[0].borderColor = borderColor
     @property
     def normalizedCoords(self):
         return self._ptr[0].normalizedCoords
     @normalizedCoords.setter
     def normalizedCoords(self, int normalizedCoords):
-        pass
         self._ptr[0].normalizedCoords = normalizedCoords
     @property
     def maxAnisotropy(self):
         return self._ptr[0].maxAnisotropy
     @maxAnisotropy.setter
     def maxAnisotropy(self, unsigned int maxAnisotropy):
-        pass
         self._ptr[0].maxAnisotropy = maxAnisotropy
     @property
     def mipmapFilterMode(self):
         return cudaTextureFilterMode(self._ptr[0].mipmapFilterMode)
     @mipmapFilterMode.setter
     def mipmapFilterMode(self, mipmapFilterMode not None : cudaTextureFilterMode):
-        pass
         self._ptr[0].mipmapFilterMode = mipmapFilterMode.value
     @property
     def mipmapLevelBias(self):
         return self._ptr[0].mipmapLevelBias
     @mipmapLevelBias.setter
     def mipmapLevelBias(self, float mipmapLevelBias):
-        pass
         self._ptr[0].mipmapLevelBias = mipmapLevelBias
     @property
     def minMipmapLevelClamp(self):
         return self._ptr[0].minMipmapLevelClamp
     @minMipmapLevelClamp.setter
     def minMipmapLevelClamp(self, float minMipmapLevelClamp):
-        pass
         self._ptr[0].minMipmapLevelClamp = minMipmapLevelClamp
     @property
     def maxMipmapLevelClamp(self):
         return self._ptr[0].maxMipmapLevelClamp
     @maxMipmapLevelClamp.setter
     def maxMipmapLevelClamp(self, float maxMipmapLevelClamp):
-        pass
         self._ptr[0].maxMipmapLevelClamp = maxMipmapLevelClamp
     @property
     def disableTrilinearOptimization(self):
         return self._ptr[0].disableTrilinearOptimization
     @disableTrilinearOptimization.setter
     def disableTrilinearOptimization(self, int disableTrilinearOptimization):
-        pass
         self._ptr[0].disableTrilinearOptimization = disableTrilinearOptimization
     @property
     def seamlessCubemap(self):
         return self._ptr[0].seamlessCubemap
     @seamlessCubemap.setter
     def seamlessCubemap(self, int seamlessCubemap):
-        pass
         self._ptr[0].seamlessCubemap = seamlessCubemap
 {{endif}}
-{{if True or 'cudaEglPlaneDesc_st' in found_types}}
+{{if True}}
 
 cdef class cudaEglPlaneDesc_st:
     """
@@ -9458,7 +10014,7 @@ cdef class cudaEglPlaneDesc_st:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaEglPlaneDesc_st *>_ptr
+            self._ptr = <cyruntime.cudaEglPlaneDesc_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
         self._channelDesc = cudaChannelFormatDesc(_ptr=<void_ptr>&self._ptr[0].channelDesc)
     def __dealloc__(self):
@@ -9468,76 +10024,84 @@ cdef class cudaEglPlaneDesc_st:
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['width : ' + str(self.width)]
-            str_list += ['height : ' + str(self.height)]
-            str_list += ['depth : ' + str(self.depth)]
-            str_list += ['pitch : ' + str(self.pitch)]
-            str_list += ['numChannels : ' + str(self.numChannels)]
-            str_list += ['channelDesc :\n' + '\n'.join(['    ' + line for line in str(self.channelDesc).splitlines()])]
-            str_list += ['reserved : ' + str(self.reserved)]
+            try:
+                str_list += ['width : ' + str(self.width)]
+            except ValueError:
+                str_list += ['width : <ValueError>']
+            try:
+                str_list += ['height : ' + str(self.height)]
+            except ValueError:
+                str_list += ['height : <ValueError>']
+            try:
+                str_list += ['depth : ' + str(self.depth)]
+            except ValueError:
+                str_list += ['depth : <ValueError>']
+            try:
+                str_list += ['pitch : ' + str(self.pitch)]
+            except ValueError:
+                str_list += ['pitch : <ValueError>']
+            try:
+                str_list += ['numChannels : ' + str(self.numChannels)]
+            except ValueError:
+                str_list += ['numChannels : <ValueError>']
+            try:
+                str_list += ['channelDesc :\n' + '\n'.join(['    ' + line for line in str(self.channelDesc).splitlines()])]
+            except ValueError:
+                str_list += ['channelDesc : <ValueError>']
+            try:
+                str_list += ['reserved : ' + str(self.reserved)]
+            except ValueError:
+                str_list += ['reserved : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def width(self):
         return self._ptr[0].width
     @width.setter
     def width(self, unsigned int width):
-        pass
         self._ptr[0].width = width
     @property
     def height(self):
         return self._ptr[0].height
     @height.setter
     def height(self, unsigned int height):
-        pass
         self._ptr[0].height = height
     @property
     def depth(self):
         return self._ptr[0].depth
     @depth.setter
     def depth(self, unsigned int depth):
-        pass
         self._ptr[0].depth = depth
     @property
     def pitch(self):
         return self._ptr[0].pitch
     @pitch.setter
     def pitch(self, unsigned int pitch):
-        pass
         self._ptr[0].pitch = pitch
     @property
     def numChannels(self):
         return self._ptr[0].numChannels
     @numChannels.setter
     def numChannels(self, unsigned int numChannels):
-        pass
         self._ptr[0].numChannels = numChannels
     @property
     def channelDesc(self):
         return self._channelDesc
     @channelDesc.setter
     def channelDesc(self, channelDesc not None : cudaChannelFormatDesc):
-        pass
-        for _attr in dir(channelDesc):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._channelDesc, _attr, getattr(channelDesc, _attr))
+        string.memcpy(&self._ptr[0].channelDesc, <cyruntime.cudaChannelFormatDesc*><void_ptr>channelDesc.getPtr(), sizeof(self._ptr[0].channelDesc))
     @property
     def reserved(self):
         return self._ptr[0].reserved
     @reserved.setter
     def reserved(self, reserved):
-        pass
         self._ptr[0].reserved = reserved
 {{endif}}
-{{if True or 'cudaEglFrame_st' in found_types}}
+{{if True}}
 
-cdef class _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
+cdef class anon_union7:
     """
-
     Attributes
     ----------
     pArray : List[cudaArray_t]
@@ -9552,20 +10116,28 @@ cdef class _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
 
     """
     def __cinit__(self, void_ptr _ptr):
-        self._ptr = <ccudart.cudaEglFrame_st *>_ptr
+        self._ptr = <cyruntime.cudaEglFrame_st *>_ptr
+
     def __init__(self, void_ptr _ptr):
         pass
+    def __dealloc__(self):
+        pass
     def getPtr(self):
-        return <void_ptr>self._ptr
+        return <void_ptr>&self._ptr[0].frame
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['pArray : ' + str(self.pArray)]
-            str_list += ['pPitch :\n' + '\n'.join(['    ' + line for line in str(self.pPitch).splitlines()])]
+            try:
+                str_list += ['pArray : ' + str(self.pArray)]
+            except ValueError:
+                str_list += ['pArray : <ValueError>']
+            try:
+                str_list += ['pPitch :\n' + '\n'.join(['    ' + line for line in str(self.pPitch).splitlines()])]
+            except ValueError:
+                str_list += ['pPitch : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def pArray(self):
         return [cudaArray_t(init_value=<void_ptr>_pArray) for _pArray in self._ptr[0].frame.pArray]
@@ -9575,21 +10147,23 @@ cdef class _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u:
             raise IndexError('not enough values found during array assignment, expected 3, got', len(pArray))
         pArray = [int(_pArray) for _pArray in pArray]
         for _idx, _pArray in enumerate(pArray):
-            self._ptr[0].frame.pArray[_idx] = <ccudart.cudaArray_t><void_ptr>_pArray
+            self._ptr[0].frame.pArray[_idx] = <cyruntime.cudaArray_t><void_ptr>_pArray
+
     @property
     def pPitch(self):
         out_pPitch = [cudaPitchedPtr() for _pPitch in self._ptr[0].frame.pPitch]
         for _idx in range(len(out_pPitch)):
-            memcpy(<ccudart.cudaPitchedPtr*><void_ptr>out_pPitch[_idx].getPtr(), &self._ptr[0].frame.pPitch[_idx], sizeof(ccudart.cudaPitchedPtr))
+            string.memcpy(<cyruntime.cudaPitchedPtr*><void_ptr>out_pPitch[_idx].getPtr(), &self._ptr[0].frame.pPitch[_idx], sizeof(cyruntime.cudaPitchedPtr))
         return out_pPitch
     @pPitch.setter
     def pPitch(self, pPitch : List[cudaPitchedPtr]):
         if len(pPitch) != 3:
             raise IndexError('not enough values found during array assignment, expected 3, got', len(pPitch))
         for _idx in range(len(pPitch)):
-            memcpy(&self._ptr[0].frame.pPitch[_idx], <ccudart.cudaPitchedPtr*><void_ptr>pPitch[_idx].getPtr(), sizeof(ccudart.cudaPitchedPtr))
+            string.memcpy(&self._ptr[0].frame.pPitch[_idx], <cyruntime.cudaPitchedPtr*><void_ptr>pPitch[_idx].getPtr(), sizeof(cyruntime.cudaPitchedPtr))
+
 {{endif}}
-{{if True or 'cudaEglFrame_st' in found_types}}
+{{if True}}
 
 cdef class cudaEglFrame_st:
     """
@@ -9604,7 +10178,7 @@ cdef class cudaEglFrame_st:
 
     Attributes
     ----------
-    frame : _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u
+    frame : anon_union7
 
     planeDesc : List[cudaEglPlaneDesc]
         CUDA EGL Plane Descriptor cudaEglPlaneDesc
@@ -9623,131 +10197,144 @@ cdef class cudaEglFrame_st:
     """
     def __cinit__(self, void_ptr _ptr = 0):
         if _ptr == 0:
-            self._ptr = &self.__val
+            self._val_ptr = <cyruntime.cudaEglFrame_st *>calloc(1, sizeof(cyruntime.cudaEglFrame_st))
+            self._ptr = self._val_ptr
         else:
-            self._ptr = <ccudart.cudaEglFrame_st *>_ptr
+            self._ptr = <cyruntime.cudaEglFrame_st *>_ptr
     def __init__(self, void_ptr _ptr = 0):
-        self._frame = _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u(_ptr=<void_ptr>self._ptr)
+        self._frame = anon_union7(_ptr=<void_ptr>self._ptr)
     def __dealloc__(self):
-        pass
+        if self._val_ptr is not NULL:
+            free(self._val_ptr)
     def getPtr(self):
         return <void_ptr>self._ptr
     def __repr__(self):
         if self._ptr is not NULL:
             str_list = []
-            str_list += ['frame :\n' + '\n'.join(['    ' + line for line in str(self.frame).splitlines()])]
-            str_list += ['planeDesc :\n' + '\n'.join(['    ' + line for line in str(self.planeDesc).splitlines()])]
-            str_list += ['planeCount : ' + str(self.planeCount)]
-            str_list += ['frameType : ' + str(self.frameType)]
-            str_list += ['eglColorFormat : ' + str(self.eglColorFormat)]
+            try:
+                str_list += ['frame :\n' + '\n'.join(['    ' + line for line in str(self.frame).splitlines()])]
+            except ValueError:
+                str_list += ['frame : <ValueError>']
+            try:
+                str_list += ['planeDesc :\n' + '\n'.join(['    ' + line for line in str(self.planeDesc).splitlines()])]
+            except ValueError:
+                str_list += ['planeDesc : <ValueError>']
+            try:
+                str_list += ['planeCount : ' + str(self.planeCount)]
+            except ValueError:
+                str_list += ['planeCount : <ValueError>']
+            try:
+                str_list += ['frameType : ' + str(self.frameType)]
+            except ValueError:
+                str_list += ['frameType : <ValueError>']
+            try:
+                str_list += ['eglColorFormat : ' + str(self.eglColorFormat)]
+            except ValueError:
+                str_list += ['eglColorFormat : <ValueError>']
             return '\n'.join(str_list)
         else:
             return ''
-
     @property
     def frame(self):
         return self._frame
     @frame.setter
-    def frame(self, frame not None : _cudaEglFrame_cudaEglFrame_cudaEglFrame_st_frame_u):
-        pass
-        for _attr in dir(frame):
-            if _attr == 'getPtr':
-                continue
-            if not _attr.startswith('_'):
-                setattr(self._frame, _attr, getattr(frame, _attr))
+    def frame(self, frame not None : anon_union7):
+        string.memcpy(&self._ptr[0].frame, <cyruntime.anon_union7*><void_ptr>frame.getPtr(), sizeof(self._ptr[0].frame))
     @property
     def planeDesc(self):
         out_planeDesc = [cudaEglPlaneDesc() for _planeDesc in self._ptr[0].planeDesc]
         for _idx in range(len(out_planeDesc)):
-            memcpy(<ccudart.cudaEglPlaneDesc*><void_ptr>out_planeDesc[_idx].getPtr(), &self._ptr[0].planeDesc[_idx], sizeof(ccudart.cudaEglPlaneDesc))
+            string.memcpy(<cyruntime.cudaEglPlaneDesc*><void_ptr>out_planeDesc[_idx].getPtr(), &self._ptr[0].planeDesc[_idx], sizeof(cyruntime.cudaEglPlaneDesc))
         return out_planeDesc
     @planeDesc.setter
     def planeDesc(self, planeDesc : List[cudaEglPlaneDesc]):
         if len(planeDesc) != 3:
             raise IndexError('not enough values found during array assignment, expected 3, got', len(planeDesc))
         for _idx in range(len(planeDesc)):
-            memcpy(&self._ptr[0].planeDesc[_idx], <ccudart.cudaEglPlaneDesc*><void_ptr>planeDesc[_idx].getPtr(), sizeof(ccudart.cudaEglPlaneDesc))
+            string.memcpy(&self._ptr[0].planeDesc[_idx], <cyruntime.cudaEglPlaneDesc*><void_ptr>planeDesc[_idx].getPtr(), sizeof(cyruntime.cudaEglPlaneDesc))
+
     @property
     def planeCount(self):
         return self._ptr[0].planeCount
     @planeCount.setter
     def planeCount(self, unsigned int planeCount):
-        pass
         self._ptr[0].planeCount = planeCount
     @property
     def frameType(self):
         return cudaEglFrameType(self._ptr[0].frameType)
     @frameType.setter
     def frameType(self, frameType not None : cudaEglFrameType):
-        pass
         self._ptr[0].frameType = frameType.value
     @property
     def eglColorFormat(self):
         return cudaEglColorFormat(self._ptr[0].eglColorFormat)
     @eglColorFormat.setter
     def eglColorFormat(self, eglColorFormat not None : cudaEglColorFormat):
-        pass
         self._ptr[0].eglColorFormat = eglColorFormat.value
 {{endif}}
-{{if True or 'GLenum' in found_types}}
+{{if 'cudaSurfaceObject_t' in found_types}}
 
-cdef class GLenum:
+cdef class cudaSurfaceObject_t:
     """
 
+    An opaque value that represents a CUDA Surface object
+
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    def __cinit__(self, unsigned int init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.GLenum *>_ptr
+            self._ptr = <cyruntime.cudaSurfaceObject_t *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<GLenum ' + str(self.__int__()) + '>'
+        return '<cudaSurfaceObject_t ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <unsigned int>self._ptr[0]
+        return <unsigned long long>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'GLuint' in found_types}}
+{{if 'cudaTextureObject_t' in found_types}}
 
-cdef class GLuint:
+cdef class cudaTextureObject_t:
     """
 
+    An opaque value that represents a CUDA texture object
+
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    def __cinit__(self, unsigned int init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.GLuint *>_ptr
+            self._ptr = <cyruntime.cudaTextureObject_t *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<GLuint ' + str(self.__int__()) + '>'
+        return '<cudaTextureObject_t ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <unsigned int>self._ptr[0]
+        return <unsigned long long>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'EGLint' in found_types}}
+{{if True}}
 
-cdef class EGLint:
+cdef class GLenum:
     """
 
     Methods
@@ -9760,22 +10347,22 @@ cdef class EGLint:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.EGLint *>_ptr
+            self._ptr = <cyruntime.GLenum *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<EGLint ' + str(self.__int__()) + '>'
+        return '<GLenum ' + str(self.__int__()) + '>'
     def __int__(self):
         return <unsigned int>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpDevice' in found_types}}
+{{if True}}
 
-cdef class VdpDevice:
+cdef class GLuint:
     """
 
     Methods
@@ -9784,26 +10371,26 @@ cdef class VdpDevice:
         Get memory address of class instance
 
     """
-    def __cinit__(self, uint32_t init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned int init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.VdpDevice *>_ptr
+            self._ptr = <cyruntime.GLuint *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<VdpDevice ' + str(self.__int__()) + '>'
+        return '<GLuint ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <uint32_t>self._ptr[0]
+        return <unsigned int>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpGetProcAddress' in found_types}}
+{{if True}}
 
-cdef class VdpGetProcAddress:
+cdef class EGLint:
     """
 
     Methods
@@ -9812,26 +10399,26 @@ cdef class VdpGetProcAddress:
         Get memory address of class instance
 
     """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned int init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.VdpGetProcAddress *>_ptr
+            self._ptr = <cyruntime.EGLint *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<VdpGetProcAddress ' + str(self.__int__()) + '>'
+        return '<EGLint ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <unsigned long long>self._ptr[0]
+        return <unsigned int>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpVideoSurface' in found_types}}
+{{if True}}
 
-cdef class VdpVideoSurface:
+cdef class VdpDevice:
     """
 
     Methods
@@ -9844,22 +10431,22 @@ cdef class VdpVideoSurface:
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.VdpVideoSurface *>_ptr
+            self._ptr = <cyruntime.VdpDevice *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<VdpVideoSurface ' + str(self.__int__()) + '>'
+        return '<VdpDevice ' + str(self.__int__()) + '>'
     def __int__(self):
         return <uint32_t>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if True or 'VdpOutputSurface' in found_types}}
+{{if True}}
 
-cdef class VdpOutputSurface:
+cdef class VdpGetProcAddress:
     """
 
     Methods
@@ -9868,552 +10455,469 @@ cdef class VdpOutputSurface:
         Get memory address of class instance
 
     """
-    def __cinit__(self, uint32_t init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.VdpOutputSurface *>_ptr
+            self._ptr = <cyruntime.VdpGetProcAddress *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<VdpOutputSurface ' + str(self.__int__()) + '>'
+        return '<VdpGetProcAddress ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <uint32_t>self._ptr[0]
+        return <unsigned long long>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'cudaSurfaceObject_t' in found_types}}
+{{if True}}
 
-cdef class cudaSurfaceObject_t:
+cdef class VdpVideoSurface:
     """
 
-    An opaque value that represents a CUDA Surface object
-
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, uint32_t init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaSurfaceObject_t *>_ptr
+            self._ptr = <cyruntime.VdpVideoSurface *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<cudaSurfaceObject_t ' + str(self.__int__()) + '>'
+        return '<VdpVideoSurface ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <unsigned long long>self._ptr[0]
+        return <uint32_t>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-{{if 'cudaTextureObject_t' in found_types}}
+{{if True}}
 
-cdef class cudaTextureObject_t:
+cdef class VdpOutputSurface:
     """
 
-    An opaque value that represents a CUDA texture object
-
     Methods
     -------
     getPtr()
         Get memory address of class instance
 
     """
-    def __cinit__(self, unsigned long long init_value = 0, void_ptr _ptr = 0):
+    def __cinit__(self, uint32_t init_value = 0, void_ptr _ptr = 0):
         if _ptr == 0:
             self._ptr = &self.__val
         else:
-            self._ptr = <ccudart.cudaTextureObject_t *>_ptr
+            self._ptr = <cyruntime.VdpOutputSurface *>_ptr
         if init_value:
             self._ptr[0] = init_value
     def __dealloc__(self):
         pass
     def __repr__(self):
-        return '<cudaTextureObject_t ' + str(self.__int__()) + '>'
+        return '<VdpOutputSurface ' + str(self.__int__()) + '>'
     def __int__(self):
-        return <unsigned long long>self._ptr[0]
+        return <uint32_t>self._ptr[0]
     def getPtr(self):
         return <void_ptr>self._ptr
 {{endif}}
 
-
-{{if True or 'cudaVDPAUGetDevice' in found_functions}}
+{{if 'cudaDeviceReset' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
-    """ Gets the CUDA device associated with a VdpDevice.
+def cudaDeviceReset():
+    """ Destroy all allocations and reset all state on the current device in the current process.
 
-    Returns the CUDA device associated with a VdpDevice, if applicable.
+    Explicitly destroys and cleans up all resources associated with the
+    current device in the current process. It is the caller's
+    responsibility to ensure that the resources are not accessed or passed
+    in subsequent API calls and doing so will result in undefined behavior.
+    These resources include CUDA types such as :py:obj:`~.cudaStream_t`,
+    :py:obj:`~.cudaEvent_t`, :py:obj:`~.cudaArray_t`,
+    :py:obj:`~.cudaMipmappedArray_t`, :py:obj:`~.cudaTextureObject_t`,
+    :py:obj:`~.cudaSurfaceObject_t`, :py:obj:`~.textureReference`,
+    :py:obj:`~.surfaceReference`, :py:obj:`~.cudaExternalMemory_t`,
+    :py:obj:`~.cudaExternalSemaphore_t` and
+    :py:obj:`~.cudaGraphicsResource_t`. Any subsequent API call to this
+    device will reinitialize the device.
 
-    Parameters
-    ----------
-    vdpDevice : :py:obj:`~.VdpDevice`
-        A VdpDevice handle
-    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
-        VDPAU's VdpGetProcAddress function pointer
+    Note that this function will reset the device immediately. It is the
+    caller's responsibility to ensure that the device is not being accessed
+    by any other host threads from the process when this function is
+    called.
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`
-    device : int
-        Returns the device associated with vdpDevice, or -1 if the device
-        associated with vdpDevice is not a compute device.
 
     See Also
     --------
-    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cuVDPAUGetDevice`
+    :py:obj:`~.cudaDeviceSynchronize`
     """
-    cdef ccudart.VdpGetProcAddress *cvdpGetProcAddress
-    if vdpGetProcAddress is None:
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>NULL
-    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress)):
-        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
-    elif isinstance(vdpGetProcAddress, (int)):
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
-    else:
-        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, cudart.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
-
-    cdef ccudart.VdpDevice cvdpDevice
-    if vdpDevice is None:
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>0
-    elif isinstance(vdpDevice, (VdpDevice)):
-        pvdpDevice = int(vdpDevice)
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>pvdpDevice
-    else:
-        pvdpDevice = int(VdpDevice(vdpDevice))
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>pvdpDevice
-
-    cdef int device = 0
-    err = ccudart.cudaVDPAUGetDevice(&device, cvdpDevice, cvdpGetProcAddress)
-    return (cudaError_t(err), device)
+    err = cyruntime.cudaDeviceReset()
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaVDPAUSetVDPAUDevice' in found_functions}}
+{{if 'cudaDeviceSynchronize' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress):
-    """ Sets a CUDA device to use VDPAU interoperability.
-
-    Records `vdpDevice` as the VdpDevice for VDPAU interoperability with
-    the CUDA device `device` and sets `device` as the current device for
-    the calling host thread.
-
-    If `device` has already been initialized then this call will fail with
-    the error :py:obj:`~.cudaErrorSetOnActiveProcess`. In this case it is
-    necessary to reset `device` using :py:obj:`~.cudaDeviceReset()` before
-    VDPAU interoperability on `device` may be enabled.
+def cudaDeviceSynchronize():
+    """ Wait for compute device to finish.
 
-    Parameters
-    ----------
-    device : int
-        Device to use for VDPAU interoperability
-    vdpDevice : :py:obj:`~.VdpDevice`
-        The VdpDevice to interoperate with
-    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
-        VDPAU's VdpGetProcAddress function pointer
+    Blocks until the device has completed all preceding requested tasks.
+    :py:obj:`~.cudaDeviceSynchronize()` returns an error if one of the
+    preceding tasks has failed. If the
+    :py:obj:`~.cudaDeviceScheduleBlockingSync` flag was set for this
+    device, the host thread will block until the device has finished its
+    work.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`
+        :py:obj:`~.cudaSuccess`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cudaGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cudaDeviceReset`
+    :py:obj:`~.cudaDeviceReset`, :py:obj:`~.cuCtxSynchronize`
     """
-    cdef ccudart.VdpGetProcAddress *cvdpGetProcAddress
-    if vdpGetProcAddress is None:
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>NULL
-    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress)):
-        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
-    elif isinstance(vdpGetProcAddress, (int)):
-        cvdpGetProcAddress = <ccudart.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
-    else:
-        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, cudart.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
-
-    cdef ccudart.VdpDevice cvdpDevice
-    if vdpDevice is None:
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>0
-    elif isinstance(vdpDevice, (VdpDevice)):
-        pvdpDevice = int(vdpDevice)
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>pvdpDevice
-    else:
-        pvdpDevice = int(VdpDevice(vdpDevice))
-        cvdpDevice = <ccudart.VdpDevice><void_ptr>pvdpDevice
+    with nogil:
+        err = cyruntime.cudaDeviceSynchronize()
 
-    err = ccudart.cudaVDPAUSetVDPAUDevice(device, cvdpDevice, cvdpGetProcAddress)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaGraphicsVDPAURegisterVideoSurface' in found_functions}}
+{{if 'cudaDeviceSetLimit' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
-    """ Register a VdpVideoSurface object.
+def cudaDeviceSetLimit(limit not None : cudaLimit, size_t value):
+    """ Set resource limits.
 
-    Registers the VdpVideoSurface specified by `vdpSurface` for access by
-    CUDA. A handle to the registered object is returned as `resource`. The
-    surface's intended usage is specified using `flags`, as follows:
+    Setting `limit` to `value` is a request by the application to update
+    the current limit maintained by the device. The driver is free to
+    modify the requested value to meet h/w requirements (this could be
+    clamping to minimum or maximum values, rounding up to nearest element
+    size, etc). The application can use :py:obj:`~.cudaDeviceGetLimit()` to
+    find out exactly what the limit has been set to.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how
-      this resource will be used. It is therefore assumed that this
-      resource will be read from and written to by CUDA. This is the
-      default value.
+    Setting each :py:obj:`~.cudaLimit` has its own specific restrictions,
+    so each is discussed here.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsReadOnly`: Specifies that CUDA will
-      not write to this resource.
+    - :py:obj:`~.cudaLimitStackSize` controls the stack size in bytes of
+      each GPU thread.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsWriteDiscard`: Specifies that CUDA
-      will not read from this resource and will write over the entire
-      contents of the resource, so none of the data previously stored in
-      the resource will be preserved.
+    - :py:obj:`~.cudaLimitPrintfFifoSize` controls the size in bytes of the
+      shared FIFO used by the :py:obj:`~.printf()` device system call.
+      Setting :py:obj:`~.cudaLimitPrintfFifoSize` must not be performed
+      after launching any kernel that uses the :py:obj:`~.printf()` device
+      system call - in such case :py:obj:`~.cudaErrorInvalidValue` will be
+      returned.
+
+    - :py:obj:`~.cudaLimitMallocHeapSize` controls the size in bytes of the
+      heap used by the :py:obj:`~.malloc()` and :py:obj:`~.free()` device
+      system calls. Setting :py:obj:`~.cudaLimitMallocHeapSize` must not be
+      performed after launching any kernel that uses the
+      :py:obj:`~.malloc()` or :py:obj:`~.free()` device system calls - in
+      such case :py:obj:`~.cudaErrorInvalidValue` will be returned.
+
+    - :py:obj:`~.cudaLimitDevRuntimeSyncDepth` controls the maximum nesting
+      depth of a grid at which a thread can safely call
+      :py:obj:`~.cudaDeviceSynchronize()`. Setting this limit must be
+      performed before any launch of a kernel that uses the device runtime
+      and calls :py:obj:`~.cudaDeviceSynchronize()` above the default sync
+      depth, two levels of grids. Calls to
+      :py:obj:`~.cudaDeviceSynchronize()` will fail with error code
+      :py:obj:`~.cudaErrorSyncDepthExceeded` if the limitation is violated.
+      This limit can be set smaller than the default or up the maximum
+      launch depth of 24. When setting this limit, keep in mind that
+      additional levels of sync depth require the runtime to reserve large
+      amounts of device memory which can no longer be used for user
+      allocations. If these reservations of device memory fail,
+      :py:obj:`~.cudaDeviceSetLimit` will return
+      :py:obj:`~.cudaErrorMemoryAllocation`, and the limit can be reset to
+      a lower value. This limit is only applicable to devices of compute
+      capability 3.5 and higher. Attempting to set this limit on devices of
+      compute capability less than 3.5 will result in the error
+      :py:obj:`~.cudaErrorUnsupportedLimit` being returned.
+
+    - :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` controls the
+      maximum number of outstanding device runtime launches that can be
+      made from the current device. A grid is outstanding from the point of
+      launch up until the grid is known to have been completed. Device
+      runtime launches which violate this limitation fail and return
+      :py:obj:`~.cudaErrorLaunchPendingCountExceeded` when
+      :py:obj:`~.cudaGetLastError()` is called after launch. If more
+      pending launches than the default (2048 launches) are needed for a
+      module using the device runtime, this limit can be increased. Keep in
+      mind that being able to sustain additional pending launches will
+      require the runtime to reserve larger amounts of device memory
+      upfront which can no longer be used for allocations. If these
+      reservations fail, :py:obj:`~.cudaDeviceSetLimit` will return
+      :py:obj:`~.cudaErrorMemoryAllocation`, and the limit can be reset to
+      a lower value. This limit is only applicable to devices of compute
+      capability 3.5 and higher. Attempting to set this limit on devices of
+      compute capability less than 3.5 will result in the error
+      :py:obj:`~.cudaErrorUnsupportedLimit` being returned.
+
+    - :py:obj:`~.cudaLimitMaxL2FetchGranularity` controls the L2 cache
+      fetch granularity. Values can range from 0B to 128B. This is purely a
+      performance hint and it can be ignored or clamped depending on the
+      platform.
+
+    - :py:obj:`~.cudaLimitPersistingL2CacheSize` controls size in bytes
+      available for persisting L2 cache. This is purely a performance hint
+      and it can be ignored or clamped depending on the platform.
 
     Parameters
     ----------
-    vdpSurface : :py:obj:`~.VdpVideoSurface`
-        VDPAU object to be registered
-    flags : unsigned int
-        Map flags
+    limit : :py:obj:`~.cudaLimit`
+        Limit to set
+    value : size_t
+        Size of limit
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
-    resource : :py:obj:`~.cudaGraphicsResource`
-        Pointer to the returned object handle
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
 
     See Also
     --------
-    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`
+    :py:obj:`~.cudaDeviceGetLimit`, :py:obj:`~.cuCtxSetLimit`
     """
-    cdef ccudart.VdpVideoSurface cvdpSurface
-    if vdpSurface is None:
-        cvdpSurface = <ccudart.VdpVideoSurface><void_ptr>0
-    elif isinstance(vdpSurface, (VdpVideoSurface)):
-        pvdpSurface = int(vdpSurface)
-        cvdpSurface = <ccudart.VdpVideoSurface><void_ptr>pvdpSurface
-    else:
-        pvdpSurface = int(VdpVideoSurface(vdpSurface))
-        cvdpSurface = <ccudart.VdpVideoSurface><void_ptr>pvdpSurface
-
-    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
-    err = ccudart.cudaGraphicsVDPAURegisterVideoSurface(resource._ptr, cvdpSurface, flags)
-    return (cudaError_t(err), resource)
+    cdef cyruntime.cudaLimit cylimit = limit.value
+    err = cyruntime.cudaDeviceSetLimit(cylimit, value)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaGraphicsVDPAURegisterOutputSurface' in found_functions}}
+{{if 'cudaDeviceGetLimit' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
-    """ Register a VdpOutputSurface object.
+def cudaDeviceGetLimit(limit not None : cudaLimit):
+    """ Returns resource limits.
 
-    Registers the VdpOutputSurface specified by `vdpSurface` for access by
-    CUDA. A handle to the registered object is returned as `resource`. The
-    surface's intended usage is specified using `flags`, as follows:
+    - Returns in `*pValue` the current size of `limit`. The following
+      :py:obj:`~.cudaLimit` values are supported.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how
-      this resource will be used. It is therefore assumed that this
-      resource will be read from and written to by CUDA. This is the
-      default value.
+    :py:obj:`~.cudaLimitStackSize` is the stack size in bytes of each GPU
+    thread.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsReadOnly`: Specifies that CUDA will
-      not write to this resource.
+    - :py:obj:`~.cudaLimitPrintfFifoSize` is the size in bytes of the
+      shared FIFO used by the :py:obj:`~.printf()` device system call.
 
-    - :py:obj:`~.cudaGraphicsMapFlagsWriteDiscard`: Specifies that CUDA
-      will not read from this resource and will write over the entire
-      contents of the resource, so none of the data previously stored in
-      the resource will be preserved.
+    - :py:obj:`~.cudaLimitMallocHeapSize` is the size in bytes of the heap
+      used by the :py:obj:`~.malloc()` and :py:obj:`~.free()` device system
+      calls.
+
+    - :py:obj:`~.cudaLimitDevRuntimeSyncDepth` is the maximum grid depth at
+      which a thread can isssue the device runtime call
+      :py:obj:`~.cudaDeviceSynchronize()` to wait on child grid launches to
+      complete.
+
+    - :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` is the maximum
+      number of outstanding device runtime launches.
+
+    - :py:obj:`~.cudaLimitMaxL2FetchGranularity` is the L2 cache fetch
+      granularity.
+
+    - :py:obj:`~.cudaLimitPersistingL2CacheSize` is the persisting L2 cache
+      size in bytes.
 
     Parameters
     ----------
-    vdpSurface : :py:obj:`~.VdpOutputSurface`
-        VDPAU object to be registered
-    flags : unsigned int
-        Map flags
+    limit : :py:obj:`~.cudaLimit`
+        Limit to query
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
-    resource : :py:obj:`~.cudaGraphicsResource`
-        Pointer to the returned object handle
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
+    pValue : int
+        Returned size of the limit
 
     See Also
     --------
-    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`
+    :py:obj:`~.cudaDeviceSetLimit`, :py:obj:`~.cuCtxGetLimit`
     """
-    cdef ccudart.VdpOutputSurface cvdpSurface
-    if vdpSurface is None:
-        cvdpSurface = <ccudart.VdpOutputSurface><void_ptr>0
-    elif isinstance(vdpSurface, (VdpOutputSurface)):
-        pvdpSurface = int(vdpSurface)
-        cvdpSurface = <ccudart.VdpOutputSurface><void_ptr>pvdpSurface
-    else:
-        pvdpSurface = int(VdpOutputSurface(vdpSurface))
-        cvdpSurface = <ccudart.VdpOutputSurface><void_ptr>pvdpSurface
-
-    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
-    err = ccudart.cudaGraphicsVDPAURegisterOutputSurface(resource._ptr, cvdpSurface, flags)
-    return (cudaError_t(err), resource)
+    cdef size_t pValue = 0
+    cdef cyruntime.cudaLimit cylimit = limit.value
+    err = cyruntime.cudaDeviceGetLimit(&pValue, cylimit)
+    return (cudaError_t(err), pValue)
 {{endif}}
 
-{{if True or 'cudaGLGetDevices' in found_functions}}
+{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : cudaGLDeviceList):
-    """ Gets the CUDA devices associated with the current OpenGL context.
+def cudaDeviceGetTexture1DLinearMaxWidth(fmtDesc : Optional[cudaChannelFormatDesc], int device):
+    """ Returns the maximum number of elements allocatable in a 1D linear texture for a given element size.
 
-    Returns in `*pCudaDeviceCount` the number of CUDA-compatible devices
-    corresponding to the current OpenGL context. Also returns in
-    `*pCudaDevices` at most `cudaDeviceCount` of the CUDA-compatible
-    devices corresponding to the current OpenGL context. If any of the GPUs
-    being used by the current OpenGL context are not CUDA capable then the
-    call will return cudaErrorNoDevice.
+    Returns in `maxWidthInElements` the maximum number of elements
+    allocatable in a 1D linear texture for given format descriptor
+    `fmtDesc`.
 
     Parameters
     ----------
-    cudaDeviceCount : unsigned int
-        The size of the output device array `pCudaDevices`
-    deviceList : cudaGLDeviceList
-        The set of devices to return. This set may be cudaGLDeviceListAll
-        for all devices, cudaGLDeviceListCurrentFrame for the devices used
-        to render the current frame (in SLI), or cudaGLDeviceListNextFrame
-        for the devices used to render the next frame (in SLI).
+    fmtDesc : :py:obj:`~.cudaChannelFormatDesc`
+        Texture format description.
+    None : int
+        None
 
     Returns
     -------
     cudaError_t
-        cudaSuccess
-        cudaErrorNoDevice
-        cudaErrorInvalidGraphicsContext
-        cudaErrorUnknown
-    pCudaDeviceCount : unsigned int
-        Returned number of CUDA devices corresponding to the current OpenGL
-        context
-    pCudaDevices : List[int]
-        Returned CUDA devices corresponding to the current OpenGL context
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
+    maxWidthInElements : int
+        Returns maximum number of texture elements allocatable for given
+        `fmtDesc`.
 
     See Also
     --------
-    ~.cudaGraphicsUnregisterResource
-    ~.cudaGraphicsMapResources
-    ~.cudaGraphicsSubResourceGetMappedArray
-    ~.cudaGraphicsResourceGetMappedPointer
-    ~.cuGLGetDevices
-
-    Notes
-    -----
-    This function is not supported on Mac OS X.
-
+    :py:obj:`~.cuDeviceGetMaxTexture1DLinear`,
     """
-    cdef unsigned int pCudaDeviceCount = 0
-    cdef int* cpCudaDevices = NULL
-    pypCudaDevices = []
-    if cudaDeviceCount != 0:
-        cpCudaDevices = <int*>calloc(cudaDeviceCount, sizeof(int))
-        if cpCudaDevices is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(cudaDeviceCount) + 'x' + str(sizeof(int)))
-    cdef ccudart.cudaGLDeviceList cdeviceList = deviceList.value
-    err = ccudart.cudaGLGetDevices(&pCudaDeviceCount, cpCudaDevices, cudaDeviceCount, cdeviceList)
-    if cudaError_t(err) == cudaError_t(0):
-        pypCudaDevices = [<void_ptr>cpCudaDevices[idx] for idx in range(cudaDeviceCount)]
-    if cpCudaDevices is not NULL:
-        free(cpCudaDevices)
-    return (cudaError_t(err), pCudaDeviceCount, pypCudaDevices)
+    cdef size_t maxWidthInElements = 0
+    cdef cyruntime.cudaChannelFormatDesc* cyfmtDesc_ptr = fmtDesc._ptr if fmtDesc != None else NULL
+    err = cyruntime.cudaDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cyfmtDesc_ptr, device)
+    return (cudaError_t(err), maxWidthInElements)
 {{endif}}
 
-{{if True or 'cudaGraphicsGLRegisterImage' in found_functions}}
+{{if 'cudaDeviceGetCacheConfig' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphicsGLRegisterImage(image, target, unsigned int flags):
-    """ Register an OpenGL texture or renderbuffer object.
+def cudaDeviceGetCacheConfig():
+    """ Returns the preferred cache configuration for the current device.
 
-    Registers the texture or renderbuffer object specified by `image` for
-    access by CUDA. A handle to the registered object is returned as
-    `resource`.
+    On devices where the L1 cache and shared memory use the same hardware
+    resources, this returns through `pCacheConfig` the preferred cache
+    configuration for the current device. This is only a preference. The
+    runtime will use the requested configuration if possible, but it is
+    free to choose a different configuration if required to execute
+    functions.
 
-    `target` must match the type of the object, and must be one of
-    :py:obj:`~.GL_TEXTURE_2D`, :py:obj:`~.GL_TEXTURE_RECTANGLE`,
-    :py:obj:`~.GL_TEXTURE_CUBE_MAP`, :py:obj:`~.GL_TEXTURE_3D`,
-    :py:obj:`~.GL_TEXTURE_2D_ARRAY`, or :py:obj:`~.GL_RENDERBUFFER`.
-
-    The register flags `flags` specify the intended usage, as follows:
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
-      how this resource will be used. It is therefore assumed that this
-      resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
-      will not write to this resource.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
-      CUDA will not read from this resource and will write over the entire
-      contents of the resource, so none of the data previously stored in
-      the resource will be preserved.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsSurfaceLoadStore`: Specifies that
-      CUDA will bind this resource to a surface reference.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsTextureGather`: Specifies that
-      CUDA will perform texture gather operations on this resource.
-
-    The following image formats are supported. For brevity's sake, the list
-    is abbreviated. For ex., {GL_R, GL_RG} X {8, 16} would expand to the
-    following 4 formats {GL_R8, GL_R16, GL_RG8, GL_RG16} :
-
-    - GL_RED, GL_RG, GL_RGBA, GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA,
-      GL_INTENSITY
-
-    - {GL_R, GL_RG, GL_RGBA} X {8, 16, 16F, 32F, 8UI, 16UI, 32UI, 8I, 16I,
-      32I}
+    This will return a `pCacheConfig` of
+    :py:obj:`~.cudaFuncCachePreferNone` on devices where the size of the L1
+    cache and shared memory are fixed.
 
-    - {GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY} X {8, 16,
-      16F_ARB, 32F_ARB, 8UI_EXT, 16UI_EXT, 32UI_EXT, 8I_EXT, 16I_EXT,
-      32I_EXT}
+    The supported cache configurations are:
 
-    The following image classes are currently disallowed:
+    - :py:obj:`~.cudaFuncCachePreferNone`: no preference for shared memory
+      or L1 (default)
 
-    - Textures with borders
+    - :py:obj:`~.cudaFuncCachePreferShared`: prefer larger shared memory
+      and smaller L1 cache
 
-    - Multisampled renderbuffers
+    - :py:obj:`~.cudaFuncCachePreferL1`: prefer larger L1 cache and smaller
+      shared memory
 
-    Parameters
-    ----------
-    image : :py:obj:`~.GLuint`
-        name of texture or renderbuffer object to be registered
-    target : :py:obj:`~.GLenum`
-        Identifies the type of object specified by `image`
-    flags : unsigned int
-        Register flags
+    - :py:obj:`~.cudaFuncCachePreferEqual`: prefer equal size L1 cache and
+      shared memory
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
-    resource : :py:obj:`~.cudaGraphicsResource`
-        Pointer to the returned object handle
+        :py:obj:`~.cudaSuccess`
+    pCacheConfig : :py:obj:`~.cudaFuncCache`
+        Returned cache configuration
 
     See Also
     --------
-    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsGLRegisterImage`
+    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaFuncSetCacheConfig (C API)`, cudaFuncSetCacheConfig (C++ API), :py:obj:`~.cuCtxGetCacheConfig`
     """
-    cdef ccudart.GLenum ctarget
-    if target is None:
-        ctarget = <ccudart.GLenum><void_ptr>0
-    elif isinstance(target, (GLenum)):
-        ptarget = int(target)
-        ctarget = <ccudart.GLenum><void_ptr>ptarget
-    else:
-        ptarget = int(GLenum(target))
-        ctarget = <ccudart.GLenum><void_ptr>ptarget
-
-    cdef ccudart.GLuint cimage
-    if image is None:
-        cimage = <ccudart.GLuint><void_ptr>0
-    elif isinstance(image, (GLuint)):
-        pimage = int(image)
-        cimage = <ccudart.GLuint><void_ptr>pimage
-    else:
-        pimage = int(GLuint(image))
-        cimage = <ccudart.GLuint><void_ptr>pimage
-
-    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
-    err = ccudart.cudaGraphicsGLRegisterImage(resource._ptr, cimage, ctarget, flags)
-    return (cudaError_t(err), resource)
+    cdef cyruntime.cudaFuncCache pCacheConfig
+    err = cyruntime.cudaDeviceGetCacheConfig(&pCacheConfig)
+    return (cudaError_t(err), cudaFuncCache(pCacheConfig))
 {{endif}}
 
-{{if True or 'cudaGraphicsGLRegisterBuffer' in found_functions}}
+{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphicsGLRegisterBuffer(buffer, unsigned int flags):
-    """ Registers an OpenGL buffer object.
-
-    Registers the buffer object specified by `buffer` for access by CUDA. A
-    handle to the registered object is returned as `resource`. The register
-    flags `flags` specify the intended usage, as follows:
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
-      how this resource will be used. It is therefore assumed that this
-      resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
-      will not write to this resource.
+def cudaDeviceGetStreamPriorityRange():
+    """ Returns numerical values that correspond to the least and greatest stream priorities.
 
-    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
-      CUDA will not read from this resource and will write over the entire
-      contents of the resource, so none of the data previously stored in
-      the resource will be preserved.
+    Returns in `*leastPriority` and `*greatestPriority` the numerical
+    values that correspond to the least and greatest stream priorities
+    respectively. Stream priorities follow a convention where lower numbers
+    imply greater priorities. The range of meaningful stream priorities is
+    given by [`*greatestPriority`, `*leastPriority`]. If the user attempts
+    to create a stream with a priority value that is outside the the
+    meaningful range as specified by this API, the priority is
+    automatically clamped down or up to either `*leastPriority` or
+    `*greatestPriority` respectively. See
+    :py:obj:`~.cudaStreamCreateWithPriority` for details on creating a
+    priority stream. A NULL may be passed in for `*leastPriority` or
+    `*greatestPriority` if the value is not desired.
 
-    Parameters
-    ----------
-    buffer : :py:obj:`~.GLuint`
-        name of buffer object to be registered
-    flags : unsigned int
-        Register flags
+    This function will return '0' in both `*leastPriority` and
+    `*greatestPriority` if the current context's device does not support
+    stream priorities (see :py:obj:`~.cudaDeviceGetAttribute`).
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
-    resource : :py:obj:`~.cudaGraphicsResource`
-        Pointer to the returned object handle
+        :py:obj:`~.cudaSuccess`
+    leastPriority : int
+        Pointer to an int in which the numerical value for least stream
+        priority is returned
+    greatestPriority : int
+        Pointer to an int in which the numerical value for greatest stream
+        priority is returned
 
     See Also
     --------
-    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsGLRegisterBuffer`
+    :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`
     """
-    cdef ccudart.GLuint cbuffer
-    if buffer is None:
-        cbuffer = <ccudart.GLuint><void_ptr>0
-    elif isinstance(buffer, (GLuint)):
-        pbuffer = int(buffer)
-        cbuffer = <ccudart.GLuint><void_ptr>pbuffer
-    else:
-        pbuffer = int(GLuint(buffer))
-        cbuffer = <ccudart.GLuint><void_ptr>pbuffer
-
-    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
-    err = ccudart.cudaGraphicsGLRegisterBuffer(resource._ptr, cbuffer, flags)
-    return (cudaError_t(err), resource)
+    cdef int leastPriority = 0
+    cdef int greatestPriority = 0
+    err = cyruntime.cudaDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority)
+    return (cudaError_t(err), leastPriority, greatestPriority)
 {{endif}}
 
-{{if 'cudaDeviceReset' in found_functions}}
+{{if 'cudaDeviceSetCacheConfig' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceReset():
-    """ Destroy all allocations and reset all state on the current device in the current process.
+def cudaDeviceSetCacheConfig(cacheConfig not None : cudaFuncCache):
+    """ Sets the preferred cache configuration for the current device.
 
-    Explicitly destroys and cleans up all resources associated with the
-    current device in the current process. It is the caller's
-    responsibility to ensure that the resources are not accessed or passed
-    in subsequent API calls and doing so will result in undefined behavior.
-    These resources include CUDA types such as :py:obj:`~.cudaStream_t`,
-    :py:obj:`~.cudaEvent_t`, :py:obj:`~.cudaArray_t`,
-    :py:obj:`~.cudaMipmappedArray_t`, :py:obj:`~.cudaTextureObject_t`,
-    :py:obj:`~.cudaSurfaceObject_t`, :py:obj:`~.textureReference`,
-    :py:obj:`~.surfaceReference`, :py:obj:`~.cudaExternalMemory_t`,
-    :py:obj:`~.cudaExternalSemaphore_t` and
-    :py:obj:`~.cudaGraphicsResource_t`. Any subsequent API call to this
-    device will reinitialize the device.
+    On devices where the L1 cache and shared memory use the same hardware
+    resources, this sets through `cacheConfig` the preferred cache
+    configuration for the current device. This is only a preference. The
+    runtime will use the requested configuration if possible, but it is
+    free to choose a different configuration if required to execute the
+    function. Any function preference set via
+    :py:obj:`~.cudaFuncSetCacheConfig (C API)` or cudaFuncSetCacheConfig
+    (C++ API) will be preferred over this device-wide setting. Setting the
+    device-wide cache configuration to :py:obj:`~.cudaFuncCachePreferNone`
+    will cause subsequent kernel launches to prefer to not change the cache
+    configuration unless required to launch the kernel.
 
-    Note that this function will reset the device immediately. It is the
-    caller's responsibility to ensure that the device is not being accessed
-    by any other host threads from the process when this function is
-    called.
+    This setting does nothing on devices where the size of the L1 cache and
+    shared memory are fixed.
+
+    Launching a kernel with a different preference than the most recent
+    preference setting may insert a device-side synchronization point.
+
+    The supported cache configurations are:
+
+    - :py:obj:`~.cudaFuncCachePreferNone`: no preference for shared memory
+      or L1 (default)
+
+    - :py:obj:`~.cudaFuncCachePreferShared`: prefer larger shared memory
+      and smaller L1 cache
+
+    - :py:obj:`~.cudaFuncCachePreferL1`: prefer larger L1 cache and smaller
+      shared memory
+
+    - :py:obj:`~.cudaFuncCachePreferEqual`: prefer equal size L1 cache and
+      shared memory
+
+    Parameters
+    ----------
+    cacheConfig : :py:obj:`~.cudaFuncCache`
+        Requested cache configuration
 
     Returns
     -------
@@ -10422,1688 +10926,1148 @@ def cudaDeviceReset():
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSynchronize`
+    :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaFuncSetCacheConfig (C API)`, cudaFuncSetCacheConfig (C++ API), :py:obj:`~.cuCtxSetCacheConfig`
     """
-    err = ccudart.cudaDeviceReset()
+    cdef cyruntime.cudaFuncCache cycacheConfig = cacheConfig.value
+    err = cyruntime.cudaDeviceSetCacheConfig(cycacheConfig)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceSynchronize' in found_functions}}
+{{if 'cudaDeviceGetSharedMemConfig' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceSynchronize():
-    """ Wait for compute device to finish.
+def cudaDeviceGetSharedMemConfig():
+    """ Returns the shared memory configuration for the current device.
 
-    Blocks until the device has completed all preceding requested tasks.
-    :py:obj:`~.cudaDeviceSynchronize()` returns an error if one of the
-    preceding tasks has failed. If the
-    :py:obj:`~.cudaDeviceScheduleBlockingSync` flag was set for this
-    device, the host thread will block until the device has finished its
-    work.
+    This function will return in `pConfig` the current size of shared
+    memory banks on the current device. On devices with configurable shared
+    memory banks, :py:obj:`~.cudaDeviceSetSharedMemConfig` can be used to
+    change this setting, so that all subsequent kernel launches will by
+    default use the new bank size. When
+    :py:obj:`~.cudaDeviceGetSharedMemConfig` is called on devices without
+    configurable shared memory, it will return the fixed bank size of the
+    hardware.
+
+    The returned bank configurations can be either:
+
+    - :py:obj:`~.cudaSharedMemBankSizeFourByte` - shared memory bank width
+      is four bytes.
+
+    - :py:obj:`~.cudaSharedMemBankSizeEightByte` - shared memory bank width
+      is eight bytes.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pConfig : :py:obj:`~.cudaSharedMemConfig`
+        Returned cache configuration
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceReset`, :py:obj:`~.cuCtxSynchronize`
+    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaDeviceSetSharedMemConfig`, :py:obj:`~.cudaFuncSetCacheConfig`, :py:obj:`~.cuCtxGetSharedMemConfig`
     """
-    with nogil:
-        err = ccudart.cudaDeviceSynchronize()
-    return (cudaError_t(err),)
+    cdef cyruntime.cudaSharedMemConfig pConfig
+    err = cyruntime.cudaDeviceGetSharedMemConfig(&pConfig)
+    return (cudaError_t(err), cudaSharedMemConfig(pConfig))
 {{endif}}
 
-{{if 'cudaDeviceSetLimit' in found_functions}}
+{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceSetLimit(limit not None : cudaLimit, size_t value):
-    """ Set resource limits.
-
-    Setting `limit` to `value` is a request by the application to update
-    the current limit maintained by the device. The driver is free to
-    modify the requested value to meet h/w requirements (this could be
-    clamping to minimum or maximum values, rounding up to nearest element
-    size, etc). The application can use :py:obj:`~.cudaDeviceGetLimit()` to
-    find out exactly what the limit has been set to.
+def cudaDeviceSetSharedMemConfig(config not None : cudaSharedMemConfig):
+    """ Sets the shared memory configuration for the current device.
 
-    Setting each :py:obj:`~.cudaLimit` has its own specific restrictions,
-    so each is discussed here.
+    On devices with configurable shared memory banks, this function will
+    set the shared memory bank size which is used for all subsequent kernel
+    launches. Any per-function setting of shared memory set via
+    :py:obj:`~.cudaFuncSetSharedMemConfig` will override the device wide
+    setting.
 
-    - :py:obj:`~.cudaLimitStackSize` controls the stack size in bytes of
-      each GPU thread.
+    Changing the shared memory configuration between launches may introduce
+    a device side synchronization point.
 
-    - :py:obj:`~.cudaLimitPrintfFifoSize` controls the size in bytes of the
-      shared FIFO used by the :py:obj:`~.printf()` device system call.
-      Setting :py:obj:`~.cudaLimitPrintfFifoSize` must not be performed
-      after launching any kernel that uses the :py:obj:`~.printf()` device
-      system call - in such case :py:obj:`~.cudaErrorInvalidValue` will be
-      returned.
+    Changing the shared memory bank size will not increase shared memory
+    usage or affect occupancy of kernels, but may have major effects on
+    performance. Larger bank sizes will allow for greater potential
+    bandwidth to shared memory, but will change what kinds of accesses to
+    shared memory will result in bank conflicts.
 
-    - :py:obj:`~.cudaLimitMallocHeapSize` controls the size in bytes of the
-      heap used by the :py:obj:`~.malloc()` and :py:obj:`~.free()` device
-      system calls. Setting :py:obj:`~.cudaLimitMallocHeapSize` must not be
-      performed after launching any kernel that uses the
-      :py:obj:`~.malloc()` or :py:obj:`~.free()` device system calls - in
-      such case :py:obj:`~.cudaErrorInvalidValue` will be returned.
+    This function will do nothing on devices with fixed shared memory bank
+    size.
 
-    - :py:obj:`~.cudaLimitDevRuntimeSyncDepth` controls the maximum nesting
-      depth of a grid at which a thread can safely call
-      :py:obj:`~.cudaDeviceSynchronize()`. Setting this limit must be
-      performed before any launch of a kernel that uses the device runtime
-      and calls :py:obj:`~.cudaDeviceSynchronize()` above the default sync
-      depth, two levels of grids. Calls to
-      :py:obj:`~.cudaDeviceSynchronize()` will fail with error code
-      :py:obj:`~.cudaErrorSyncDepthExceeded` if the limitation is violated.
-      This limit can be set smaller than the default or up the maximum
-      launch depth of 24. When setting this limit, keep in mind that
-      additional levels of sync depth require the runtime to reserve large
-      amounts of device memory which can no longer be used for user
-      allocations. If these reservations of device memory fail,
-      :py:obj:`~.cudaDeviceSetLimit` will return
-      :py:obj:`~.cudaErrorMemoryAllocation`, and the limit can be reset to
-      a lower value. This limit is only applicable to devices of compute
-      capability 3.5 and higher. Attempting to set this limit on devices of
-      compute capability less than 3.5 will result in the error
-      :py:obj:`~.cudaErrorUnsupportedLimit` being returned.
+    The supported bank configurations are:
 
-    - :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` controls the
-      maximum number of outstanding device runtime launches that can be
-      made from the current device. A grid is outstanding from the point of
-      launch up until the grid is known to have been completed. Device
-      runtime launches which violate this limitation fail and return
-      :py:obj:`~.cudaErrorLaunchPendingCountExceeded` when
-      :py:obj:`~.cudaGetLastError()` is called after launch. If more
-      pending launches than the default (2048 launches) are needed for a
-      module using the device runtime, this limit can be increased. Keep in
-      mind that being able to sustain additional pending launches will
-      require the runtime to reserve larger amounts of device memory
-      upfront which can no longer be used for allocations. If these
-      reservations fail, :py:obj:`~.cudaDeviceSetLimit` will return
-      :py:obj:`~.cudaErrorMemoryAllocation`, and the limit can be reset to
-      a lower value. This limit is only applicable to devices of compute
-      capability 3.5 and higher. Attempting to set this limit on devices of
-      compute capability less than 3.5 will result in the error
-      :py:obj:`~.cudaErrorUnsupportedLimit` being returned.
+    - :py:obj:`~.cudaSharedMemBankSizeDefault`: set bank width the device
+      default (currently, four bytes)
 
-    - :py:obj:`~.cudaLimitMaxL2FetchGranularity` controls the L2 cache
-      fetch granularity. Values can range from 0B to 128B. This is purely a
-      performance hint and it can be ignored or clamped depending on the
-      platform.
+    - :py:obj:`~.cudaSharedMemBankSizeFourByte`: set shared memory bank
+      width to be four bytes natively.
 
-    - :py:obj:`~.cudaLimitPersistingL2CacheSize` controls size in bytes
-      available for persisting L2 cache. This is purely a performance hint
-      and it can be ignored or clamped depending on the platform.
+    - :py:obj:`~.cudaSharedMemBankSizeEightByte`: set shared memory bank
+      width to be eight bytes natively.
 
     Parameters
     ----------
-    limit : :py:obj:`~.cudaLimit`
-        Limit to set
-    value : size_t
-        Size of limit
+    config : :py:obj:`~.cudaSharedMemConfig`
+        Requested cache configuration
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceGetLimit`, :py:obj:`~.cuCtxSetLimit`
+    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaDeviceGetSharedMemConfig`, :py:obj:`~.cudaFuncSetCacheConfig`, :py:obj:`~.cuCtxSetSharedMemConfig`
     """
-    cdef ccudart.cudaLimit climit = limit.value
-    err = ccudart.cudaDeviceSetLimit(climit, value)
+    cdef cyruntime.cudaSharedMemConfig cyconfig = config.value
+    err = cyruntime.cudaDeviceSetSharedMemConfig(cyconfig)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceGetLimit' in found_functions}}
+{{if 'cudaDeviceGetByPCIBusId' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetLimit(limit not None : cudaLimit):
-    """ Returns resource limits.
-
-    - Returns in `*pValue` the current size of `limit`. The following
-      :py:obj:`~.cudaLimit` values are supported.
-
-    :py:obj:`~.cudaLimitStackSize` is the stack size in bytes of each GPU
-    thread.
-
-    - :py:obj:`~.cudaLimitPrintfFifoSize` is the size in bytes of the
-      shared FIFO used by the :py:obj:`~.printf()` device system call.
-
-    - :py:obj:`~.cudaLimitMallocHeapSize` is the size in bytes of the heap
-      used by the :py:obj:`~.malloc()` and :py:obj:`~.free()` device system
-      calls.
-
-    - :py:obj:`~.cudaLimitDevRuntimeSyncDepth` is the maximum grid depth at
-      which a thread can isssue the device runtime call
-      :py:obj:`~.cudaDeviceSynchronize()` to wait on child grid launches to
-      complete.
-
-    - :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` is the maximum
-      number of outstanding device runtime launches.
+def cudaDeviceGetByPCIBusId(char* pciBusId):
+    """ Returns a handle to a compute device.
 
-    - :py:obj:`~.cudaLimitMaxL2FetchGranularity` is the L2 cache fetch
-      granularity.
+    Returns in `*device` a device ordinal given a PCI bus ID string.
 
-    - :py:obj:`~.cudaLimitPersistingL2CacheSize` is the persisting L2 cache
-      size in bytes.
+    where `domain`, `bus`, `device`, and `function` are all hexadecimal
+    values
 
     Parameters
     ----------
-    limit : :py:obj:`~.cudaLimit`
-        Limit to query
+    pciBusId : bytes
+        String in one of the following forms:
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
-    pValue : int
-        Returned size of the limit
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
+    device : int
+        Returned device ordinal
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSetLimit`, :py:obj:`~.cuCtxGetLimit`
+    :py:obj:`~.cudaDeviceGetPCIBusId`, :py:obj:`~.cuDeviceGetByPCIBusId`
     """
-    cdef size_t pValue = 0
-    cdef ccudart.cudaLimit climit = limit.value
-    err = ccudart.cudaDeviceGetLimit(&pValue, climit)
-    return (cudaError_t(err), pValue)
+    cdef int device = 0
+    err = cyruntime.cudaDeviceGetByPCIBusId(&device, pciBusId)
+    return (cudaError_t(err), device)
 {{endif}}
 
-{{if 'cudaDeviceGetTexture1DLinearMaxWidth' in found_functions}}
+{{if 'cudaDeviceGetPCIBusId' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetTexture1DLinearMaxWidth(fmtDesc : Optional[cudaChannelFormatDesc], int device):
-    """ Returns the maximum number of elements allocatable in a 1D linear texture for a given element size.
+def cudaDeviceGetPCIBusId(int length, int device):
+    """ Returns a PCI Bus Id string for the device.
 
-    Returns in `maxWidthInElements` the maximum number of elements
-    allocatable in a 1D linear texture for given format descriptor
-    `fmtDesc`.
+    Returns an ASCII string identifying the device `dev` in the NULL-
+    terminated string pointed to by `pciBusId`. `length` specifies the
+    maximum length of the string that may be returned.
+
+    where `domain`, `bus`, `device`, and `function` are all hexadecimal
+    values. pciBusId should be large enough to store 13 characters
+    including the NULL-terminator.
 
     Parameters
     ----------
-    fmtDesc : :py:obj:`~.cudaChannelFormatDesc`
-        Texture format description.
-    None : int
-        None
+    length : int
+        Maximum length of string to store in `name`
+    device : int
+        Device to get identifier string for
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
-    maxWidthInElements : int
-        Returns maximum number of texture elements allocatable for given
-        `fmtDesc`.
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
+    pciBusId : bytes
+        Returned identifier string for the device in the following format
 
     See Also
     --------
-    :py:obj:`~.cuDeviceGetMaxTexture1DLinear`,
+    :py:obj:`~.cudaDeviceGetByPCIBusId`, :py:obj:`~.cuDeviceGetPCIBusId`
     """
-    cdef size_t maxWidthInElements = 0
-    cdef ccudart.cudaChannelFormatDesc* cfmtDesc_ptr = fmtDesc._ptr if fmtDesc != None else NULL
-    err = ccudart.cudaDeviceGetTexture1DLinearMaxWidth(&maxWidthInElements, cfmtDesc_ptr, device)
-    return (cudaError_t(err), maxWidthInElements)
+    pypciBusId = b" " * length
+    cdef char* pciBusId = pypciBusId
+    err = cyruntime.cudaDeviceGetPCIBusId(pciBusId, length, device)
+    return (cudaError_t(err), pypciBusId)
 {{endif}}
 
-{{if 'cudaDeviceGetCacheConfig' in found_functions}}
+{{if 'cudaIpcGetEventHandle' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetCacheConfig():
-    """ Returns the preferred cache configuration for the current device.
-
-    On devices where the L1 cache and shared memory use the same hardware
-    resources, this returns through `pCacheConfig` the preferred cache
-    configuration for the current device. This is only a preference. The
-    runtime will use the requested configuration if possible, but it is
-    free to choose a different configuration if required to execute
-    functions.
-
-    This will return a `pCacheConfig` of
-    :py:obj:`~.cudaFuncCachePreferNone` on devices where the size of the L1
-    cache and shared memory are fixed.
-
-    The supported cache configurations are:
+def cudaIpcGetEventHandle(event):
+    """ Gets an interprocess handle for a previously allocated event.
 
-    - :py:obj:`~.cudaFuncCachePreferNone`: no preference for shared memory
-      or L1 (default)
+    Takes as input a previously allocated event. This event must have been
+    created with the :py:obj:`~.cudaEventInterprocess` and
+    :py:obj:`~.cudaEventDisableTiming` flags set. This opaque handle may be
+    copied into other processes and opened with
+    :py:obj:`~.cudaIpcOpenEventHandle` to allow efficient hardware
+    synchronization between GPU work in different processes.
 
-    - :py:obj:`~.cudaFuncCachePreferShared`: prefer larger shared memory
-      and smaller L1 cache
+    After the event has been been opened in the importing process,
+    :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventSynchronize`,
+    :py:obj:`~.cudaStreamWaitEvent` and :py:obj:`~.cudaEventQuery` may be
+    used in either process. Performing operations on the imported event
+    after the exported event has been freed with
+    :py:obj:`~.cudaEventDestroy` will result in undefined behavior.
 
-    - :py:obj:`~.cudaFuncCachePreferL1`: prefer larger L1 cache and smaller
-      shared memory
+    IPC functionality is restricted to devices with support for unified
+    addressing on Linux operating systems. IPC functionality is not
+    supported on Tegra platforms.
 
-    - :py:obj:`~.cudaFuncCachePreferEqual`: prefer equal size L1 cache and
-      shared memory
+    Parameters
+    ----------
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Event allocated with :py:obj:`~.cudaEventInterprocess` and
+        :py:obj:`~.cudaEventDisableTiming` flags.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
-    pCacheConfig : :py:obj:`~.cudaFuncCache`
-        Returned cache configuration
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+    handle : :py:obj:`~.cudaIpcEventHandle_t`
+        Pointer to a user allocated cudaIpcEventHandle in which to return
+        the opaque event handle
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaFuncSetCacheConfig (C API)`, cudaFuncSetCacheConfig (C++ API), :py:obj:`~.cuCtxGetCacheConfig`
+    :py:obj:`~.cudaEventCreate`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcGetEventHandle`
     """
-    cdef ccudart.cudaFuncCache pCacheConfig
-    err = ccudart.cudaDeviceGetCacheConfig(&pCacheConfig)
-    return (cudaError_t(err), cudaFuncCache(pCacheConfig))
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    else:
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cudaIpcEventHandle_t handle = cudaIpcEventHandle_t()
+    err = cyruntime.cudaIpcGetEventHandle(<cyruntime.cudaIpcEventHandle_t*>handle._ptr, cyevent)
+    return (cudaError_t(err), handle)
 {{endif}}
 
-{{if 'cudaDeviceGetStreamPriorityRange' in found_functions}}
+{{if 'cudaIpcOpenEventHandle' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetStreamPriorityRange():
-    """ Returns numerical values that correspond to the least and greatest stream priorities.
+def cudaIpcOpenEventHandle(handle not None : cudaIpcEventHandle_t):
+    """ Opens an interprocess event handle for use in the current process.
 
-    Returns in `*leastPriority` and `*greatestPriority` the numerical
-    values that correspond to the least and greatest stream priorities
-    respectively. Stream priorities follow a convention where lower numbers
-    imply greater priorities. The range of meaningful stream priorities is
-    given by [`*greatestPriority`, `*leastPriority`]. If the user attempts
-    to create a stream with a priority value that is outside the the
-    meaningful range as specified by this API, the priority is
-    automatically clamped down or up to either `*leastPriority` or
-    `*greatestPriority` respectively. See
-    :py:obj:`~.cudaStreamCreateWithPriority` for details on creating a
-    priority stream. A NULL may be passed in for `*leastPriority` or
-    `*greatestPriority` if the value is not desired.
+    Opens an interprocess event handle exported from another process with
+    :py:obj:`~.cudaIpcGetEventHandle`. This function returns a
+    :py:obj:`~.cudaEvent_t` that behaves like a locally created event with
+    the :py:obj:`~.cudaEventDisableTiming` flag specified. This event must
+    be freed with :py:obj:`~.cudaEventDestroy`.
 
-    This function will return '0' in both `*leastPriority` and
-    `*greatestPriority` if the current context's device does not support
-    stream priorities (see :py:obj:`~.cudaDeviceGetAttribute`).
+    Performing operations on the imported event after the exported event
+    has been freed with :py:obj:`~.cudaEventDestroy` will result in
+    undefined behavior.
+
+    IPC functionality is restricted to devices with support for unified
+    addressing on Linux operating systems. IPC functionality is not
+    supported on Tegra platforms.
+
+    Parameters
+    ----------
+    handle : :py:obj:`~.cudaIpcEventHandle_t`
+        Interprocess handle to open
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
-    leastPriority : int
-        Pointer to an int in which the numerical value for least stream
-        priority is returned
-    greatestPriority : int
-        Pointer to an int in which the numerical value for greatest stream
-        priority is returned
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorDeviceUninitialized`
+    event : :py:obj:`~.cudaEvent_t`
+        Returns the imported event
 
     See Also
     --------
-    :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaStreamGetPriority`, :py:obj:`~.cuCtxGetStreamPriorityRange`
+    :py:obj:`~.cudaEventCreate`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcOpenEventHandle`
     """
-    cdef int leastPriority = 0
-    cdef int greatestPriority = 0
-    err = ccudart.cudaDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority)
-    return (cudaError_t(err), leastPriority, greatestPriority)
+    cdef cudaEvent_t event = cudaEvent_t()
+    err = cyruntime.cudaIpcOpenEventHandle(<cyruntime.cudaEvent_t*>event._ptr, handle._ptr[0])
+    return (cudaError_t(err), event)
 {{endif}}
 
-{{if 'cudaDeviceSetCacheConfig' in found_functions}}
+{{if 'cudaIpcGetMemHandle' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceSetCacheConfig(cacheConfig not None : cudaFuncCache):
-    """ Sets the preferred cache configuration for the current device.
-
-    On devices where the L1 cache and shared memory use the same hardware
-    resources, this sets through `cacheConfig` the preferred cache
-    configuration for the current device. This is only a preference. The
-    runtime will use the requested configuration if possible, but it is
-    free to choose a different configuration if required to execute the
-    function. Any function preference set via
-    :py:obj:`~.cudaFuncSetCacheConfig (C API)` or cudaFuncSetCacheConfig
-    (C++ API) will be preferred over this device-wide setting. Setting the
-    device-wide cache configuration to :py:obj:`~.cudaFuncCachePreferNone`
-    will cause subsequent kernel launches to prefer to not change the cache
-    configuration unless required to launch the kernel.
-
-    This setting does nothing on devices where the size of the L1 cache and
-    shared memory are fixed.
-
-    Launching a kernel with a different preference than the most recent
-    preference setting may insert a device-side synchronization point.
-
-    The supported cache configurations are:
-
-    - :py:obj:`~.cudaFuncCachePreferNone`: no preference for shared memory
-      or L1 (default)
+def cudaIpcGetMemHandle(devPtr):
+    """ Gets an interprocess memory handle for an existing device memory allocation.
 
-    - :py:obj:`~.cudaFuncCachePreferShared`: prefer larger shared memory
-      and smaller L1 cache
+    Takes a pointer to the base of an existing device memory allocation
+    created with :py:obj:`~.cudaMalloc` and exports it for use in another
+    process. This is a lightweight operation and may be called multiple
+    times on an allocation without adverse effects.
 
-    - :py:obj:`~.cudaFuncCachePreferL1`: prefer larger L1 cache and smaller
-      shared memory
+    If a region of memory is freed with :py:obj:`~.cudaFree` and a
+    subsequent call to :py:obj:`~.cudaMalloc` returns memory with the same
+    device address, :py:obj:`~.cudaIpcGetMemHandle` will return a unique
+    handle for the new memory.
 
-    - :py:obj:`~.cudaFuncCachePreferEqual`: prefer equal size L1 cache and
-      shared memory
+    IPC functionality is restricted to devices with support for unified
+    addressing on Linux operating systems. IPC functionality is not
+    supported on Tegra platforms.
 
     Parameters
     ----------
-    cacheConfig : :py:obj:`~.cudaFuncCache`
-        Requested cache configuration
+    devPtr : Any
+        Base pointer to previously allocated device memory
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+    handle : :py:obj:`~.cudaIpcMemHandle_t`
+        Pointer to user allocated :py:obj:`~.cudaIpcMemHandle` to return
+        the handle in.
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaFuncSetCacheConfig (C API)`, cudaFuncSetCacheConfig (C++ API), :py:obj:`~.cuCtxSetCacheConfig`
+    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcGetMemHandle`
     """
-    cdef ccudart.cudaFuncCache ccacheConfig = cacheConfig.value
-    err = ccudart.cudaDeviceSetCacheConfig(ccacheConfig)
-    return (cudaError_t(err),)
+    cdef cudaIpcMemHandle_t handle = cudaIpcMemHandle_t()
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaIpcGetMemHandle(<cyruntime.cudaIpcMemHandle_t*>handle._ptr, cydevPtr_ptr)
+    return (cudaError_t(err), handle)
 {{endif}}
 
-{{if 'cudaDeviceGetSharedMemConfig' in found_functions}}
+{{if 'cudaIpcOpenMemHandle' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetSharedMemConfig():
-    """ Returns the shared memory configuration for the current device.
+def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flags):
+    """ Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
 
-    This function will return in `pConfig` the current size of shared
-    memory banks on the current device. On devices with configurable shared
-    memory banks, :py:obj:`~.cudaDeviceSetSharedMemConfig` can be used to
-    change this setting, so that all subsequent kernel launches will by
-    default use the new bank size. When
-    :py:obj:`~.cudaDeviceGetSharedMemConfig` is called on devices without
-    configurable shared memory, it will return the fixed bank size of the
-    hardware.
+    Maps memory exported from another process with
+    :py:obj:`~.cudaIpcGetMemHandle` into the current device address space.
+    For contexts on different devices :py:obj:`~.cudaIpcOpenMemHandle` can
+    attempt to enable peer access between the devices as if the user called
+    :py:obj:`~.cudaDeviceEnablePeerAccess`. This behavior is controlled by
+    the :py:obj:`~.cudaIpcMemLazyEnablePeerAccess` flag.
+    :py:obj:`~.cudaDeviceCanAccessPeer` can determine if a mapping is
+    possible.
 
-    The returned bank configurations can be either:
+    :py:obj:`~.cudaIpcOpenMemHandle` can open handles to devices that may
+    not be visible in the process calling the API.
 
-    - :py:obj:`~.cudaSharedMemBankSizeFourByte` - shared memory bank width
-      is four bytes.
+    Contexts that may open :py:obj:`~.cudaIpcMemHandles` are restricted in
+    the following way. :py:obj:`~.cudaIpcMemHandles` from each device in a
+    given process may only be opened by one context per device per other
+    process.
 
-    - :py:obj:`~.cudaSharedMemBankSizeEightByte` - shared memory bank width
-      is eight bytes.
+    If the memory handle has already been opened by the current context,
+    the reference count on the handle is incremented by 1 and the existing
+    device pointer is returned.
+
+    Memory returned from :py:obj:`~.cudaIpcOpenMemHandle` must be freed
+    with :py:obj:`~.cudaIpcCloseMemHandle`.
+
+    Calling :py:obj:`~.cudaFree` on an exported memory region before
+    calling :py:obj:`~.cudaIpcCloseMemHandle` in the importing context will
+    result in undefined behavior.
+
+    IPC functionality is restricted to devices with support for unified
+    addressing on Linux operating systems. IPC functionality is not
+    supported on Tegra platforms.
+
+    Parameters
+    ----------
+    handle : :py:obj:`~.cudaIpcMemHandle_t`
+        :py:obj:`~.cudaIpcMemHandle` to open
+    flags : unsigned int
+        Flags for this operation. Must be specified as
+        :py:obj:`~.cudaIpcMemLazyEnablePeerAccess`
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pConfig : :py:obj:`~.cudaSharedMemConfig`
-        Returned cache configuration
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorDeviceUninitialized`, :py:obj:`~.cudaErrorTooManyPeers`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+    devPtr : Any
+        Returned device pointer
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaDeviceSetSharedMemConfig`, :py:obj:`~.cudaFuncSetCacheConfig`, :py:obj:`~.cuCtxGetSharedMemConfig`
+    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cudaDeviceEnablePeerAccess`, :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cuIpcOpenMemHandle`
+
+    Notes
+    -----
+    No guarantees are made about the address returned in `*devPtr`. 
+     In particular, multiple processes may not receive the same address for the same `handle`.
     """
-    cdef ccudart.cudaSharedMemConfig pConfig
-    err = ccudart.cudaDeviceGetSharedMemConfig(&pConfig)
-    return (cudaError_t(err), cudaSharedMemConfig(pConfig))
+    cdef void_ptr devPtr = 0
+    err = cyruntime.cudaIpcOpenMemHandle(<void**>&devPtr, handle._ptr[0], flags)
+    return (cudaError_t(err), devPtr)
 {{endif}}
 
-{{if 'cudaDeviceSetSharedMemConfig' in found_functions}}
+{{if 'cudaIpcCloseMemHandle' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceSetSharedMemConfig(config not None : cudaSharedMemConfig):
-    """ Sets the shared memory configuration for the current device.
-
-    On devices with configurable shared memory banks, this function will
-    set the shared memory bank size which is used for all subsequent kernel
-    launches. Any per-function setting of shared memory set via
-    :py:obj:`~.cudaFuncSetSharedMemConfig` will override the device wide
-    setting.
-
-    Changing the shared memory configuration between launches may introduce
-    a device side synchronization point.
-
-    Changing the shared memory bank size will not increase shared memory
-    usage or affect occupancy of kernels, but may have major effects on
-    performance. Larger bank sizes will allow for greater potential
-    bandwidth to shared memory, but will change what kinds of accesses to
-    shared memory will result in bank conflicts.
-
-    This function will do nothing on devices with fixed shared memory bank
-    size.
-
-    The supported bank configurations are:
+def cudaIpcCloseMemHandle(devPtr):
+    """ Attempts to close memory mapped with cudaIpcOpenMemHandle.
 
-    - :py:obj:`~.cudaSharedMemBankSizeDefault`: set bank width the device
-      default (currently, four bytes)
+    Decrements the reference count of the memory returnd by
+    :py:obj:`~.cudaIpcOpenMemHandle` by 1. When the reference count reaches
+    0, this API unmaps the memory. The original allocation in the exporting
+    process as well as imported mappings in other processes will be
+    unaffected.
 
-    - :py:obj:`~.cudaSharedMemBankSizeFourByte`: set shared memory bank
-      width to be four bytes natively.
+    Any resources used to enable peer access will be freed if this is the
+    last mapping using them.
 
-    - :py:obj:`~.cudaSharedMemBankSizeEightByte`: set shared memory bank
-      width to be eight bytes natively.
+    IPC functionality is restricted to devices with support for unified
+    addressing on Linux operating systems. IPC functionality is not
+    supported on Tegra platforms.
 
     Parameters
     ----------
-    config : :py:obj:`~.cudaSharedMemConfig`
-        Requested cache configuration
+    devPtr : Any
+        Device pointer returned by :py:obj:`~.cudaIpcOpenMemHandle`
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaDeviceGetSharedMemConfig`, :py:obj:`~.cudaFuncSetCacheConfig`, :py:obj:`~.cuCtxSetSharedMemConfig`
+    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cuIpcCloseMemHandle`
     """
-    cdef ccudart.cudaSharedMemConfig cconfig = config.value
-    err = ccudart.cudaDeviceSetSharedMemConfig(cconfig)
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaIpcCloseMemHandle(cydevPtr_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceGetByPCIBusId' in found_functions}}
+{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetByPCIBusId(char* pciBusId):
-    """ Returns a handle to a compute device.
+def cudaDeviceFlushGPUDirectRDMAWrites(target not None : cudaFlushGPUDirectRDMAWritesTarget, scope not None : cudaFlushGPUDirectRDMAWritesScope):
+    """ Blocks until remote writes are visible to the specified scope.
 
-    Returns in `*device` a device ordinal given a PCI bus ID string.
+    Blocks until remote writes to the target context via mappings created
+    through GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see
+    https://docs.nvidia.com/cuda/gpudirect-rdma for more information), are
+    visible to the specified scope.
 
-    where `domain`, `bus`, `device`, and `function` are all hexadecimal
-    values
+    If the scope equals or lies within the scope indicated by
+    :py:obj:`~.cudaDevAttrGPUDirectRDMAWritesOrdering`, the call will be a
+    no-op and can be safely omitted for performance. This can be determined
+    by comparing the numerical values between the two enums, with smaller
+    scopes having smaller values.
+
+    Users may query support for this API via
+    :py:obj:`~.cudaDevAttrGPUDirectRDMAFlushWritesOptions`.
 
     Parameters
     ----------
-    pciBusId : bytes
-        String in one of the following forms:
+    target : :py:obj:`~.cudaFlushGPUDirectRDMAWritesTarget`
+        The target of the operation, see cudaFlushGPUDirectRDMAWritesTarget
+    scope : :py:obj:`~.cudaFlushGPUDirectRDMAWritesScope`
+        The scope of the operation, see cudaFlushGPUDirectRDMAWritesScope
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
-    device : int
-        Returned device ordinal
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorNotSupported`,
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceGetPCIBusId`, :py:obj:`~.cuDeviceGetByPCIBusId`
+    :py:obj:`~.cuFlushGPUDirectRDMAWrites`
     """
-    cdef int device = 0
-    err = ccudart.cudaDeviceGetByPCIBusId(&device, pciBusId)
-    return (cudaError_t(err), device)
+    cdef cyruntime.cudaFlushGPUDirectRDMAWritesTarget cytarget = target.value
+    cdef cyruntime.cudaFlushGPUDirectRDMAWritesScope cyscope = scope.value
+    err = cyruntime.cudaDeviceFlushGPUDirectRDMAWrites(cytarget, cyscope)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceGetPCIBusId' in found_functions}}
+{{if 'cudaGetLastError' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetPCIBusId(int length, int device):
-    """ Returns a PCI Bus Id string for the device.
-
-    Returns an ASCII string identifying the device `dev` in the NULL-
-    terminated string pointed to by `pciBusId`. `length` specifies the
-    maximum length of the string that may be returned.
-
-    where `domain`, `bus`, `device`, and `function` are all hexadecimal
-    values. pciBusId should be large enough to store 13 characters
-    including the NULL-terminator.
+def cudaGetLastError():
+    """ Returns the last error from a runtime call.
 
-    Parameters
-    ----------
-    length : int
-        Maximum length of string to store in `name`
-    device : int
-        Device to get identifier string for
+    Returns the last error that has been produced by any of the runtime
+    calls in the same host thread and resets it to :py:obj:`~.cudaSuccess`.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
-    pciBusId : bytes
-        Returned identifier string for the device in the following format
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMissingConfiguration`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorLaunchOutOfResources`, :py:obj:`~.cudaErrorInvalidDeviceFunction`, :py:obj:`~.cudaErrorInvalidConfiguration`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidPitchValue`, :py:obj:`~.cudaErrorInvalidSymbol`, :py:obj:`~.cudaErrorUnmapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidDevicePointer`, :py:obj:`~.cudaErrorInvalidTexture`, :py:obj:`~.cudaErrorInvalidTextureBinding`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidMemcpyDirection`, :py:obj:`~.cudaErrorInvalidFilterSetting`, :py:obj:`~.cudaErrorInvalidNormSetting`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInsufficientDriver`, :py:obj:`~.cudaErrorNoDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`, :py:obj:`~.cudaErrorStartupFailure`, :py:obj:`~.cudaErrorInvalidPtx`, :py:obj:`~.cudaErrorUnsupportedPtxVersion`, :py:obj:`~.cudaErrorNoKernelImageForDevice`, :py:obj:`~.cudaErrorJitCompilerNotFound`, :py:obj:`~.cudaErrorJitCompilationDisabled`
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceGetByPCIBusId`, :py:obj:`~.cuDeviceGetPCIBusId`
+    :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
     """
-    pypciBusId = b" " * length
-    cdef char* pciBusId = pypciBusId
-    err = ccudart.cudaDeviceGetPCIBusId(pciBusId, length, device)
-    return (cudaError_t(err), pypciBusId)
+    err = cyruntime.cudaGetLastError()
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaIpcGetEventHandle' in found_functions}}
+{{if 'cudaPeekAtLastError' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaIpcGetEventHandle(event):
-    """ Gets an interprocess handle for a previously allocated event.
-
-    Takes as input a previously allocated event. This event must have been
-    created with the :py:obj:`~.cudaEventInterprocess` and
-    :py:obj:`~.cudaEventDisableTiming` flags set. This opaque handle may be
-    copied into other processes and opened with
-    :py:obj:`~.cudaIpcOpenEventHandle` to allow efficient hardware
-    synchronization between GPU work in different processes.
-
-    After the event has been been opened in the importing process,
-    :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventSynchronize`,
-    :py:obj:`~.cudaStreamWaitEvent` and :py:obj:`~.cudaEventQuery` may be
-    used in either process. Performing operations on the imported event
-    after the exported event has been freed with
-    :py:obj:`~.cudaEventDestroy` will result in undefined behavior.
-
-    IPC functionality is restricted to devices with support for unified
-    addressing on Linux operating systems. IPC functionality is not
-    supported on Tegra platforms.
+def cudaPeekAtLastError():
+    """ Returns the last error from a runtime call.
 
-    Parameters
-    ----------
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Event allocated with :py:obj:`~.cudaEventInterprocess` and
-        :py:obj:`~.cudaEventDisableTiming` flags.
+    Returns the last error that has been produced by any of the runtime
+    calls in the same host thread. Note that this call does not reset the
+    error to :py:obj:`~.cudaSuccess` like :py:obj:`~.cudaGetLastError()`.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
-    handle : :py:obj:`~.cudaIpcEventHandle_t`
-        Pointer to a user allocated cudaIpcEventHandle in which to return
-        the opaque event handle
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMissingConfiguration`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorLaunchOutOfResources`, :py:obj:`~.cudaErrorInvalidDeviceFunction`, :py:obj:`~.cudaErrorInvalidConfiguration`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidPitchValue`, :py:obj:`~.cudaErrorInvalidSymbol`, :py:obj:`~.cudaErrorUnmapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidDevicePointer`, :py:obj:`~.cudaErrorInvalidTexture`, :py:obj:`~.cudaErrorInvalidTextureBinding`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidMemcpyDirection`, :py:obj:`~.cudaErrorInvalidFilterSetting`, :py:obj:`~.cudaErrorInvalidNormSetting`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInsufficientDriver`, :py:obj:`~.cudaErrorNoDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`, :py:obj:`~.cudaErrorStartupFailure`, :py:obj:`~.cudaErrorInvalidPtx`, :py:obj:`~.cudaErrorUnsupportedPtxVersion`, :py:obj:`~.cudaErrorNoKernelImageForDevice`, :py:obj:`~.cudaErrorJitCompilerNotFound`, :py:obj:`~.cudaErrorJitCompilationDisabled`
 
     See Also
     --------
-    :py:obj:`~.cudaEventCreate`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcGetEventHandle`
+    :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    cdef cudaIpcEventHandle_t handle = cudaIpcEventHandle_t()
-    err = ccudart.cudaIpcGetEventHandle(handle._ptr, cevent)
-    return (cudaError_t(err), handle)
+    err = cyruntime.cudaPeekAtLastError()
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaIpcOpenEventHandle' in found_functions}}
+{{if 'cudaGetErrorName' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaIpcOpenEventHandle(handle not None : cudaIpcEventHandle_t):
-    """ Opens an interprocess event handle for use in the current process.
-
-    Opens an interprocess event handle exported from another process with
-    :py:obj:`~.cudaIpcGetEventHandle`. This function returns a
-    :py:obj:`~.cudaEvent_t` that behaves like a locally created event with
-    the :py:obj:`~.cudaEventDisableTiming` flag specified. This event must
-    be freed with :py:obj:`~.cudaEventDestroy`.
-
-    Performing operations on the imported event after the exported event
-    has been freed with :py:obj:`~.cudaEventDestroy` will result in
-    undefined behavior.
+def cudaGetErrorName(error not None : cudaError_t):
+    """ Returns the string representation of an error code enum name.
 
-    IPC functionality is restricted to devices with support for unified
-    addressing on Linux operating systems. IPC functionality is not
-    supported on Tegra platforms.
+    Returns a string containing the name of an error code in the enum. If
+    the error code is not recognized, "unrecognized error code" is
+    returned.
 
     Parameters
     ----------
-    handle : :py:obj:`~.cudaIpcEventHandle_t`
-        Interprocess handle to open
+    error : :py:obj:`~.cudaError_t`
+        Error code to convert to string
 
     Returns
     -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorDeviceUninitialized`
-    event : :py:obj:`~.cudaEvent_t`
-        Returns the imported event
+    cudaError_t.cudaSuccess
+        cudaError_t.cudaSuccess
+    bytes
+        `char*` pointer to a NULL-terminated string
 
     See Also
     --------
-    :py:obj:`~.cudaEventCreate`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcOpenEventHandle`
+    :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaError`, :py:obj:`~.cuGetErrorName`
     """
-    cdef cudaEvent_t event = cudaEvent_t()
-    err = ccudart.cudaIpcOpenEventHandle(<ccudart.cudaEvent_t*>event._ptr, handle._ptr[0])
-    return (cudaError_t(err), event)
+    cdef cyruntime.cudaError_t cyerror = error.value
+    err = cyruntime.cudaGetErrorName(cyerror)
+    return (cudaError_t.cudaSuccess, err)
 {{endif}}
 
-{{if 'cudaIpcGetMemHandle' in found_functions}}
+{{if 'cudaGetErrorString' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaIpcGetMemHandle(devPtr):
-    """ Gets an interprocess memory handle for an existing device memory allocation.
-
-    Takes a pointer to the base of an existing device memory allocation
-    created with :py:obj:`~.cudaMalloc` and exports it for use in another
-    process. This is a lightweight operation and may be called multiple
-    times on an allocation without adverse effects.
-
-    If a region of memory is freed with :py:obj:`~.cudaFree` and a
-    subsequent call to :py:obj:`~.cudaMalloc` returns memory with the same
-    device address, :py:obj:`~.cudaIpcGetMemHandle` will return a unique
-    handle for the new memory.
+def cudaGetErrorString(error not None : cudaError_t):
+    """ Returns the description string for an error code.
 
-    IPC functionality is restricted to devices with support for unified
-    addressing on Linux operating systems. IPC functionality is not
-    supported on Tegra platforms.
+    Returns the description string for an error code. If the error code is
+    not recognized, "unrecognized error code" is returned.
 
     Parameters
     ----------
-    devPtr : Any
-        Base pointer to previously allocated device memory
+    error : :py:obj:`~.cudaError_t`
+        Error code to convert to string
 
     Returns
     -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
-    handle : :py:obj:`~.cudaIpcMemHandle_t`
-        Pointer to user allocated :py:obj:`~.cudaIpcMemHandle` to return
-        the handle in.
+    cudaError_t.cudaSuccess
+        cudaError_t.cudaSuccess
+    bytes
+        `char*` pointer to a NULL-terminated string
 
     See Also
     --------
-    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cuIpcGetMemHandle`
+    :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaError`, :py:obj:`~.cuGetErrorString`
     """
-    cdef cudaIpcMemHandle_t handle = cudaIpcMemHandle_t()
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaIpcGetMemHandle(handle._ptr, cdevPtr_ptr)
-    return (cudaError_t(err), handle)
+    cdef cyruntime.cudaError_t cyerror = error.value
+    err = cyruntime.cudaGetErrorString(cyerror)
+    return (cudaError_t.cudaSuccess, err)
 {{endif}}
 
-{{if 'cudaIpcOpenMemHandle' in found_functions}}
+{{if 'cudaGetDeviceCount' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaIpcOpenMemHandle(handle not None : cudaIpcMemHandle_t, unsigned int flags):
-    """ Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
-
-    Maps memory exported from another process with
-    :py:obj:`~.cudaIpcGetMemHandle` into the current device address space.
-    For contexts on different devices :py:obj:`~.cudaIpcOpenMemHandle` can
-    attempt to enable peer access between the devices as if the user called
-    :py:obj:`~.cudaDeviceEnablePeerAccess`. This behavior is controlled by
-    the :py:obj:`~.cudaIpcMemLazyEnablePeerAccess` flag.
-    :py:obj:`~.cudaDeviceCanAccessPeer` can determine if a mapping is
-    possible.
-
-    :py:obj:`~.cudaIpcOpenMemHandle` can open handles to devices that may
-    not be visible in the process calling the API.
-
-    Contexts that may open :py:obj:`~.cudaIpcMemHandles` are restricted in
-    the following way. :py:obj:`~.cudaIpcMemHandles` from each device in a
-    given process may only be opened by one context per device per other
-    process.
-
-    If the memory handle has already been opened by the current context,
-    the reference count on the handle is incremented by 1 and the existing
-    device pointer is returned.
-
-    Memory returned from :py:obj:`~.cudaIpcOpenMemHandle` must be freed
-    with :py:obj:`~.cudaIpcCloseMemHandle`.
-
-    Calling :py:obj:`~.cudaFree` on an exported memory region before
-    calling :py:obj:`~.cudaIpcCloseMemHandle` in the importing context will
-    result in undefined behavior.
-
-    IPC functionality is restricted to devices with support for unified
-    addressing on Linux operating systems. IPC functionality is not
-    supported on Tegra platforms.
+def cudaGetDeviceCount():
+    """ Returns the number of compute-capable devices.
 
-    Parameters
-    ----------
-    handle : :py:obj:`~.cudaIpcMemHandle_t`
-        :py:obj:`~.cudaIpcMemHandle` to open
-    flags : unsigned int
-        Flags for this operation. Must be specified as
-        :py:obj:`~.cudaIpcMemLazyEnablePeerAccess`
+    Returns in `*count` the number of devices with compute capability
+    greater or equal to 2.0 that are available for execution.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorDeviceUninitialized`, :py:obj:`~.cudaErrorTooManyPeers`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
-    devPtr : Any
-        Returned device pointer
+        :py:obj:`~.cudaSuccess`
+    count : int
+        Returns the number of devices with compute capability greater or
+        equal to 2.0
 
     See Also
     --------
-    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcCloseMemHandle`, :py:obj:`~.cudaDeviceEnablePeerAccess`, :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cuIpcOpenMemHandle`
-
-    Notes
-    -----
-    No guarantees are made about the address returned in `*devPtr`. 
-     In particular, multiple processes may not receive the same address for the same `handle`.
+    :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuDeviceGetCount`
     """
-    cdef void_ptr devPtr = 0
-    err = ccudart.cudaIpcOpenMemHandle(<void**>&devPtr, handle._ptr[0], flags)
-    return (cudaError_t(err), devPtr)
+    cdef int count = 0
+    err = cyruntime.cudaGetDeviceCount(&count)
+    return (cudaError_t(err), count)
 {{endif}}
 
-{{if 'cudaIpcCloseMemHandle' in found_functions}}
+{{if 'cudaGetDeviceProperties' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaIpcCloseMemHandle(devPtr):
-    """ Attempts to close memory mapped with cudaIpcOpenMemHandle.
+def cudaGetDeviceProperties(int device):
+    """ Returns information about the compute-device.
 
-    Decrements the reference count of the memory returnd by
-    :py:obj:`~.cudaIpcOpenMemHandle` by 1. When the reference count reaches
-    0, this API unmaps the memory. The original allocation in the exporting
-    process as well as imported mappings in other processes will be
-    unaffected.
+    Returns in `*prop` the properties of device `dev`. The
+    :py:obj:`~.cudaDeviceProp` structure is defined as:
 
-    Any resources used to enable peer access will be freed if this is the
-    last mapping using them.
+    **View CUDA Toolkit Documentation for a C++ code example**
 
-    IPC functionality is restricted to devices with support for unified
-    addressing on Linux operating systems. IPC functionality is not
-    supported on Tegra platforms.
+    where:
 
-    Parameters
-    ----------
-    devPtr : Any
-        Device pointer returned by :py:obj:`~.cudaIpcOpenMemHandle`
+    - :py:obj:`~.name[256]` is an ASCII string identifying the device.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMapBufferObjectFailed`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+    - :py:obj:`~.uuid` is a 16-byte unique identifier.
 
-    See Also
-    --------
-    :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaIpcGetEventHandle`, :py:obj:`~.cudaIpcOpenEventHandle`, :py:obj:`~.cudaIpcGetMemHandle`, :py:obj:`~.cudaIpcOpenMemHandle`, :py:obj:`~.cuIpcCloseMemHandle`
-    """
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaIpcCloseMemHandle(cdevPtr_ptr)
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.totalGlobalMem` is the total amount of global memory
+      available on the device in bytes.
 
-{{if 'cudaDeviceFlushGPUDirectRDMAWrites' in found_functions}}
+    - :py:obj:`~.sharedMemPerBlock` is the maximum amount of shared memory
+      available to a thread block in bytes.
 
-@cython.embedsignature(True)
-def cudaDeviceFlushGPUDirectRDMAWrites(target not None : cudaFlushGPUDirectRDMAWritesTarget, scope not None : cudaFlushGPUDirectRDMAWritesScope):
-    """ Blocks until remote writes are visible to the specified scope.
+    - :py:obj:`~.regsPerBlock` is the maximum number of 32-bit registers
+      available to a thread block.
 
-    Blocks until remote writes to the target context via mappings created
-    through GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see
-    https://docs.nvidia.com/cuda/gpudirect-rdma for more information), are
-    visible to the specified scope.
+    - :py:obj:`~.warpSize` is the warp size in threads.
 
-    If the scope equals or lies within the scope indicated by
-    :py:obj:`~.cudaDevAttrGPUDirectRDMAWritesOrdering`, the call will be a
-    no-op and can be safely omitted for performance. This can be determined
-    by comparing the numerical values between the two enums, with smaller
-    scopes having smaller values.
+    - :py:obj:`~.memPitch` is the maximum pitch in bytes allowed by the
+      memory copy functions that involve memory regions allocated through
+      :py:obj:`~.cudaMallocPitch()`.
 
-    Users may query support for this API via
-    :py:obj:`~.cudaDevAttrGPUDirectRDMAFlushWritesOptions`.
+    - :py:obj:`~.maxThreadsPerBlock` is the maximum number of threads per
+      block.
 
-    Parameters
-    ----------
-    target : :py:obj:`~.cudaFlushGPUDirectRDMAWritesTarget`
-        The target of the operation, see cudaFlushGPUDirectRDMAWritesTarget
-    scope : :py:obj:`~.cudaFlushGPUDirectRDMAWritesScope`
-        The scope of the operation, see cudaFlushGPUDirectRDMAWritesScope
+    - :py:obj:`~.maxThreadsDim[3]` contains the maximum size of each
+      dimension of a block.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorNotSupported`,
+    - :py:obj:`~.maxGridSize[3]` contains the maximum size of each
+      dimension of a grid.
 
-    See Also
-    --------
-    :py:obj:`~.cuFlushGPUDirectRDMAWrites`
-    """
-    cdef ccudart.cudaFlushGPUDirectRDMAWritesTarget ctarget = target.value
-    cdef ccudart.cudaFlushGPUDirectRDMAWritesScope cscope = scope.value
-    err = ccudart.cudaDeviceFlushGPUDirectRDMAWrites(ctarget, cscope)
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.clockRate` is the clock frequency in kilohertz.
 
-{{if 'cudaThreadExit' in found_functions}}
+    - :py:obj:`~.totalConstMem` is the total amount of constant memory
+      available on the device in bytes.
 
-@cython.embedsignature(True)
-def cudaThreadExit():
-    """ Exit and clean up from CUDA launches.
+    - :py:obj:`~.major`, :py:obj:`~.minor` are the major and minor revision
+      numbers defining the device's compute capability.
 
-    [Deprecated]
+    - :py:obj:`~.textureAlignment` is the alignment requirement; texture
+      base addresses that are aligned to :py:obj:`~.textureAlignment` bytes
+      do not need an offset applied to texture fetches.
 
-    Note that this function is deprecated because its name does not reflect
-    its behavior. Its functionality is identical to the non-deprecated
-    function :py:obj:`~.cudaDeviceReset()`, which should be used instead.
+    - :py:obj:`~.texturePitchAlignment` is the pitch alignment requirement
+      for 2D texture references that are bound to pitched memory.
 
-    Explicitly destroys all cleans up all resources associated with the
-    current device in the current process. Any subsequent API call to this
-    device will reinitialize the device.
+    - :py:obj:`~.deviceOverlap` is 1 if the device can concurrently copy
+      memory between host and device while executing a kernel, or 0 if not.
+      Deprecated, use instead asyncEngineCount.
 
-    Note that this function will reset the device immediately. It is the
-    caller's responsibility to ensure that the device is not being accessed
-    by any other host threads from the process when this function is
-    called.
+    - :py:obj:`~.multiProcessorCount` is the number of multiprocessors on
+      the device.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`
+    - :py:obj:`~.kernelExecTimeoutEnabled` is 1 if there is a run time
+      limit for kernels executed on the device, or 0 if not.
 
-    See Also
-    --------
-    :py:obj:`~.cudaDeviceReset`
-    """
-    err = ccudart.cudaThreadExit()
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.integrated` is 1 if the device is an integrated
+      (motherboard) GPU and 0 if it is a discrete (card) component.
 
-{{if 'cudaThreadSynchronize' in found_functions}}
+    - :py:obj:`~.canMapHostMemory` is 1 if the device can map host memory
+      into the CUDA address space for use with
+      :py:obj:`~.cudaHostAlloc()`/:py:obj:`~.cudaHostGetDevicePointer()`,
+      or 0 if not.
 
-@cython.embedsignature(True)
-def cudaThreadSynchronize():
-    """ Wait for compute device to finish.
+    - :py:obj:`~.computeMode` is the compute mode that the device is
+      currently in. Available modes are as follows:
 
-    [Deprecated]
+      - cudaComputeModeDefault: Default mode - Device is not restricted and
+        multiple threads can use :py:obj:`~.cudaSetDevice()` with this
+        device.
 
-    Note that this function is deprecated because its name does not reflect
-    its behavior. Its functionality is similar to the non-deprecated
-    function :py:obj:`~.cudaDeviceSynchronize()`, which should be used
-    instead.
+      - cudaComputeModeProhibited: Compute-prohibited mode - No threads can
+        use :py:obj:`~.cudaSetDevice()` with this device.
 
-    Blocks until the device has completed all preceding requested tasks.
-    :py:obj:`~.cudaThreadSynchronize()` returns an error if one of the
-    preceding tasks has failed. If the
-    :py:obj:`~.cudaDeviceScheduleBlockingSync` flag was set for this
-    device, the host thread will block until the device has finished its
-    work.
+      - cudaComputeModeExclusiveProcess: Compute-exclusive-process mode -
+        Many threads in one process will be able to use
+        :py:obj:`~.cudaSetDevice()` with this device.   When an occupied
+        exclusive mode device is chosen with :py:obj:`~.cudaSetDevice`, all
+        subsequent non-device management runtime functions will return
+        :py:obj:`~.cudaErrorDevicesUnavailable`.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`
+    - :py:obj:`~.maxTexture1D` is the maximum 1D texture size.
 
-    See Also
-    --------
-    :py:obj:`~.cudaDeviceSynchronize`
-    """
-    err = ccudart.cudaThreadSynchronize()
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.maxTexture1DMipmap` is the maximum 1D mipmapped texture
+      texture size.
 
-{{if 'cudaThreadSetLimit' in found_functions}}
+    - :py:obj:`~.maxTexture1DLinear` is the maximum 1D texture size for
+      textures bound to linear memory.
 
-@cython.embedsignature(True)
-def cudaThreadSetLimit(limit not None : cudaLimit, size_t value):
-    """ Set resource limits.
+    - :py:obj:`~.maxTexture2D[2]` contains the maximum 2D texture
+      dimensions.
 
-    [Deprecated]
+    - :py:obj:`~.maxTexture2DMipmap[2]` contains the maximum 2D mipmapped
+      texture dimensions.
 
-    Note that this function is deprecated because its name does not reflect
-    its behavior. Its functionality is identical to the non-deprecated
-    function :py:obj:`~.cudaDeviceSetLimit()`, which should be used
-    instead.
+    - :py:obj:`~.maxTexture2DLinear[3]` contains the maximum 2D texture
+      dimensions for 2D textures bound to pitch linear memory.
 
-    Setting `limit` to `value` is a request by the application to update
-    the current limit maintained by the device. The driver is free to
-    modify the requested value to meet h/w requirements (this could be
-    clamping to minimum or maximum values, rounding up to nearest element
-    size, etc). The application can use :py:obj:`~.cudaThreadGetLimit()` to
-    find out exactly what the limit has been set to.
+    - :py:obj:`~.maxTexture2DGather[2]` contains the maximum 2D texture
+      dimensions if texture gather operations have to be performed.
 
-    Setting each :py:obj:`~.cudaLimit` has its own specific restrictions,
-    so each is discussed here.
+    - :py:obj:`~.maxTexture3D[3]` contains the maximum 3D texture
+      dimensions.
 
-    - :py:obj:`~.cudaLimitStackSize` controls the stack size of each GPU
-      thread.
+    - :py:obj:`~.maxTexture3DAlt[3]` contains the maximum alternate 3D
+      texture dimensions.
 
-    - :py:obj:`~.cudaLimitPrintfFifoSize` controls the size of the shared
-      FIFO used by the :py:obj:`~.printf()` device system call. Setting
-      :py:obj:`~.cudaLimitPrintfFifoSize` must be performed before
-      launching any kernel that uses the :py:obj:`~.printf()` device system
-      call, otherwise :py:obj:`~.cudaErrorInvalidValue` will be returned.
+    - :py:obj:`~.maxTextureCubemap` is the maximum cubemap texture width or
+      height.
 
-    - :py:obj:`~.cudaLimitMallocHeapSize` controls the size of the heap
-      used by the :py:obj:`~.malloc()` and :py:obj:`~.free()` device system
-      calls. Setting :py:obj:`~.cudaLimitMallocHeapSize` must be performed
-      before launching any kernel that uses the :py:obj:`~.malloc()` or
-      :py:obj:`~.free()` device system calls, otherwise
-      :py:obj:`~.cudaErrorInvalidValue` will be returned.
+    - :py:obj:`~.maxTexture1DLayered[2]` contains the maximum 1D layered
+      texture dimensions.
 
-    Parameters
-    ----------
-    limit : :py:obj:`~.cudaLimit`
-        Limit to set
-    value : size_t
-        Size in bytes of limit
+    - :py:obj:`~.maxTexture2DLayered[3]` contains the maximum 2D layered
+      texture dimensions.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
+    - :py:obj:`~.maxTextureCubemapLayered[2]` contains the maximum cubemap
+      layered texture dimensions.
 
-    See Also
-    --------
-    :py:obj:`~.cudaDeviceSetLimit`
-    """
-    cdef ccudart.cudaLimit climit = limit.value
-    err = ccudart.cudaThreadSetLimit(climit, value)
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.maxSurface1D` is the maximum 1D surface size.
 
-{{if 'cudaThreadGetLimit' in found_functions}}
+    - :py:obj:`~.maxSurface2D[2]` contains the maximum 2D surface
+      dimensions.
 
-@cython.embedsignature(True)
-def cudaThreadGetLimit(limit not None : cudaLimit):
-    """ Returns resource limits.
+    - :py:obj:`~.maxSurface3D[3]` contains the maximum 3D surface
+      dimensions.
 
-    [Deprecated]
+    - :py:obj:`~.maxSurface1DLayered[2]` contains the maximum 1D layered
+      surface dimensions.
 
-    Note that this function is deprecated because its name does not reflect
-    its behavior. Its functionality is identical to the non-deprecated
-    function :py:obj:`~.cudaDeviceGetLimit()`, which should be used
-    instead.
+    - :py:obj:`~.maxSurface2DLayered[3]` contains the maximum 2D layered
+      surface dimensions.
 
-    Returns in `*pValue` the current size of `limit`. The supported
-    :py:obj:`~.cudaLimit` values are:
+    - :py:obj:`~.maxSurfaceCubemap` is the maximum cubemap surface width or
+      height.
 
-    - :py:obj:`~.cudaLimitStackSize`: stack size of each GPU thread;
+    - :py:obj:`~.maxSurfaceCubemapLayered[2]` contains the maximum cubemap
+      layered surface dimensions.
 
-    - :py:obj:`~.cudaLimitPrintfFifoSize`: size of the shared FIFO used by
-      the :py:obj:`~.printf()` device system call.
+    - :py:obj:`~.surfaceAlignment` specifies the alignment requirements for
+      surfaces.
 
-    - :py:obj:`~.cudaLimitMallocHeapSize`: size of the heap used by the
-      :py:obj:`~.malloc()` and :py:obj:`~.free()` device system calls;
+    - :py:obj:`~.concurrentKernels` is 1 if the device supports executing
+      multiple kernels within the same context simultaneously, or 0 if not.
+      It is not guaranteed that multiple kernels will be resident on the
+      device concurrently so this feature should not be relied upon for
+      correctness.
 
-    Parameters
-    ----------
-    limit : :py:obj:`~.cudaLimit`
-        Limit to query
+    - :py:obj:`~.ECCEnabled` is 1 if the device has ECC support turned on,
+      or 0 if not.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorUnsupportedLimit`, :py:obj:`~.cudaErrorInvalidValue`
-    pValue : int
-        Returned size in bytes of limit
+    - :py:obj:`~.pciBusID` is the PCI bus identifier of the device.
 
-    See Also
-    --------
-    :py:obj:`~.cudaDeviceGetLimit`
-    """
-    cdef size_t pValue = 0
-    cdef ccudart.cudaLimit climit = limit.value
-    err = ccudart.cudaThreadGetLimit(&pValue, climit)
-    return (cudaError_t(err), pValue)
-{{endif}}
+    - :py:obj:`~.pciDeviceID` is the PCI device (sometimes called slot)
+      identifier of the device.
 
-{{if 'cudaGetLastError' in found_functions}}
+    - :py:obj:`~.pciDomainID` is the PCI domain identifier of the device.
 
-@cython.embedsignature(True)
-def cudaGetLastError():
-    """ Returns the last error from a runtime call.
+    - :py:obj:`~.tccDriver` is 1 if the device is using a TCC driver or 0
+      if not.
 
-    Returns the last error that has been produced by any of the runtime
-    calls in the same host thread and resets it to :py:obj:`~.cudaSuccess`.
+    - :py:obj:`~.asyncEngineCount` is 1 when the device can concurrently
+      copy memory between host and device while executing a kernel. It is 2
+      when the device can concurrently copy memory between host and device
+      in both directions and execute a kernel at the same time. It is 0 if
+      neither of these is supported.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMissingConfiguration`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorLaunchOutOfResources`, :py:obj:`~.cudaErrorInvalidDeviceFunction`, :py:obj:`~.cudaErrorInvalidConfiguration`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidPitchValue`, :py:obj:`~.cudaErrorInvalidSymbol`, :py:obj:`~.cudaErrorUnmapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidDevicePointer`, :py:obj:`~.cudaErrorInvalidTexture`, :py:obj:`~.cudaErrorInvalidTextureBinding`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidMemcpyDirection`, :py:obj:`~.cudaErrorInvalidFilterSetting`, :py:obj:`~.cudaErrorInvalidNormSetting`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInsufficientDriver`, :py:obj:`~.cudaErrorNoDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`, :py:obj:`~.cudaErrorStartupFailure`, :py:obj:`~.cudaErrorInvalidPtx`, :py:obj:`~.cudaErrorUnsupportedPtxVersion`, :py:obj:`~.cudaErrorNoKernelImageForDevice`, :py:obj:`~.cudaErrorJitCompilerNotFound`, :py:obj:`~.cudaErrorJitCompilationDisabled`
+    - :py:obj:`~.unifiedAddressing` is 1 if the device shares a unified
+      address space with the host and 0 otherwise.
 
-    See Also
-    --------
-    :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
-    """
-    err = ccudart.cudaGetLastError()
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.memoryClockRate` is the peak memory clock frequency in
+      kilohertz.
 
-{{if 'cudaPeekAtLastError' in found_functions}}
+    - :py:obj:`~.memoryBusWidth` is the memory bus width   in bits.
 
-@cython.embedsignature(True)
-def cudaPeekAtLastError():
-    """ Returns the last error from a runtime call.
+    - :py:obj:`~.l2CacheSize` is L2 cache size in bytes.
 
-    Returns the last error that has been produced by any of the runtime
-    calls in the same host thread. Note that this call does not reset the
-    error to :py:obj:`~.cudaSuccess` like :py:obj:`~.cudaGetLastError()`.
+    - :py:obj:`~.persistingL2CacheMaxSize` is L2 cache's maximum persisting
+      lines size in bytes.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorMissingConfiguration`, :py:obj:`~.cudaErrorMemoryAllocation`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorLaunchOutOfResources`, :py:obj:`~.cudaErrorInvalidDeviceFunction`, :py:obj:`~.cudaErrorInvalidConfiguration`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidPitchValue`, :py:obj:`~.cudaErrorInvalidSymbol`, :py:obj:`~.cudaErrorUnmapBufferObjectFailed`, :py:obj:`~.cudaErrorInvalidDevicePointer`, :py:obj:`~.cudaErrorInvalidTexture`, :py:obj:`~.cudaErrorInvalidTextureBinding`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidMemcpyDirection`, :py:obj:`~.cudaErrorInvalidFilterSetting`, :py:obj:`~.cudaErrorInvalidNormSetting`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInsufficientDriver`, :py:obj:`~.cudaErrorNoDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`, :py:obj:`~.cudaErrorStartupFailure`, :py:obj:`~.cudaErrorInvalidPtx`, :py:obj:`~.cudaErrorUnsupportedPtxVersion`, :py:obj:`~.cudaErrorNoKernelImageForDevice`, :py:obj:`~.cudaErrorJitCompilerNotFound`, :py:obj:`~.cudaErrorJitCompilationDisabled`
+    - :py:obj:`~.maxThreadsPerMultiProcessor`   is the number of maximum
+      resident threads per multiprocessor.
 
-    See Also
-    --------
-    :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaError`
-    """
-    err = ccudart.cudaPeekAtLastError()
-    return (cudaError_t(err),)
-{{endif}}
+    - :py:obj:`~.streamPrioritiesSupported` is 1 if the device supports
+      stream priorities, or 0 if it is not supported.
 
-{{if 'cudaGetErrorName' in found_functions}}
+    - :py:obj:`~.globalL1CacheSupported` is 1 if the device supports
+      caching of globals in L1 cache, or 0 if it is not supported.
 
-@cython.embedsignature(True)
-def cudaGetErrorName(error not None : cudaError_t):
-    """ Returns the string representation of an error code enum name.
+    - :py:obj:`~.localL1CacheSupported` is 1 if the device supports caching
+      of locals in L1 cache, or 0 if it is not supported.
 
-    Returns a string containing the name of an error code in the enum. If
-    the error code is not recognized, "unrecognized error code" is
-    returned.
+    - :py:obj:`~.sharedMemPerMultiprocessor` is the maximum amount of
+      shared memory available to a multiprocessor in bytes; this amount is
+      shared by all thread blocks simultaneously resident on a
+      multiprocessor.
 
-    Parameters
-    ----------
-    error : :py:obj:`~.cudaError_t`
-        Error code to convert to string
+    - :py:obj:`~.regsPerMultiprocessor` is the maximum number of 32-bit
+      registers available to a multiprocessor; this number is shared by all
+      thread blocks simultaneously resident on a multiprocessor.
 
-    Returns
-    -------
-    cudaError_t.cudaSuccess
-        cudaError_t.cudaSuccess
-    bytes
-        `char*` pointer to a NULL-terminated string
+    - :py:obj:`~.managedMemory` is 1 if the device supports allocating
+      managed memory on this system, or 0 if it is not supported.
 
-    See Also
-    --------
-    :py:obj:`~.cudaGetErrorString`, :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaError`, :py:obj:`~.cuGetErrorName`
-    """
-    cdef ccudart.cudaError_t cerror = error.value
-    err = ccudart.cudaGetErrorName(cerror)
-    return (cudaError_t.cudaSuccess, err)
-{{endif}}
+    - :py:obj:`~.isMultiGpuBoard` is 1 if the device is on a multi-GPU
+      board (e.g. Gemini cards), and 0 if not;
 
-{{if 'cudaGetErrorString' in found_functions}}
+    - :py:obj:`~.multiGpuBoardGroupID` is a unique identifier for a group
+      of devices associated with the same board. Devices on the same multi-
+      GPU board will share the same identifier.
 
-@cython.embedsignature(True)
-def cudaGetErrorString(error not None : cudaError_t):
-    """ Returns the description string for an error code.
+    - :py:obj:`~.singleToDoublePrecisionPerfRatio`   is the ratio of single
+      precision performance (in floating-point operations per second) to
+      double precision performance.
 
-    Returns the description string for an error code. If the error code is
-    not recognized, "unrecognized error code" is returned.
+    - :py:obj:`~.pageableMemoryAccess` is 1 if the device supports
+      coherently accessing pageable memory without calling cudaHostRegister
+      on it, and 0 otherwise.
 
-    Parameters
-    ----------
-    error : :py:obj:`~.cudaError_t`
-        Error code to convert to string
+    - :py:obj:`~.concurrentManagedAccess` is 1 if the device can coherently
+      access managed memory concurrently with the CPU, and 0 otherwise.
 
-    Returns
-    -------
-    cudaError_t.cudaSuccess
-        cudaError_t.cudaSuccess
-    bytes
-        `char*` pointer to a NULL-terminated string
+    - :py:obj:`~.computePreemptionSupported` is 1 if the device supports
+      Compute Preemption, and 0 otherwise.
 
-    See Also
-    --------
-    :py:obj:`~.cudaGetErrorName`, :py:obj:`~.cudaGetLastError`, :py:obj:`~.cudaPeekAtLastError`, :py:obj:`~.cudaError`, :py:obj:`~.cuGetErrorString`
-    """
-    cdef ccudart.cudaError_t cerror = error.value
-    err = ccudart.cudaGetErrorString(cerror)
-    return (cudaError_t.cudaSuccess, err)
-{{endif}}
+    - :py:obj:`~.canUseHostPointerForRegisteredMem` is 1 if the device can
+      access host registered memory at the same virtual address as the CPU,
+      and 0 otherwise.
 
-{{if 'cudaGetDeviceCount' in found_functions}}
+    - :py:obj:`~.cooperativeLaunch` is 1 if the device supports launching
+      cooperative kernels via :py:obj:`~.cudaLaunchCooperativeKernel`, and
+      0 otherwise.
 
-@cython.embedsignature(True)
-def cudaGetDeviceCount():
-    """ Returns the number of compute-capable devices.
+    - :py:obj:`~.cooperativeMultiDeviceLaunch` is 1 if the device supports
+      launching cooperative kernels via
+      :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice`, and 0 otherwise.
 
-    Returns in `*count` the number of devices with compute capability
-    greater or equal to 2.0 that are available for execution.
+    - :py:obj:`~.pageableMemoryAccessUsesHostPageTables` is 1 if the device
+      accesses pageable memory via the host's page tables, and 0 otherwise.
+
+    - :py:obj:`~.directManagedMemAccessFromHost` is 1 if the host can
+      directly access managed memory on the device without migration, and 0
+      otherwise.
+
+    - :py:obj:`~.maxBlocksPerMultiProcessor` is the maximum number of
+      thread blocks that can reside on a multiprocessor.
+
+    - :py:obj:`~.accessPolicyMaxWindowSize` is the maximum value of
+      :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.
+
+    Parameters
+    ----------
+    device : int
+        Device number to get properties for
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
-    count : int
-        Returns the number of devices with compute capability greater or
-        equal to 2.0
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
+    prop : :py:obj:`~.cudaDeviceProp`
+        Properties for the specified device
 
     See Also
     --------
-    :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuDeviceGetCount`
+    :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cudaDeviceGetAttribute`, :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetName`
     """
-    cdef int count = 0
-    err = ccudart.cudaGetDeviceCount(&count)
-    return (cudaError_t(err), count)
+    cdef cudaDeviceProp prop = cudaDeviceProp()
+    err = cyruntime.cudaGetDeviceProperties(<cyruntime.cudaDeviceProp*>prop._ptr, device)
+    return (cudaError_t(err), prop)
 {{endif}}
 
-{{if 'cudaGetDeviceProperties' in found_functions}}
+{{if 'cudaDeviceGetAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetDeviceProperties(int device):
-    """ Returns information about the compute-device.
+def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device):
+    """ Returns information about the device.
 
-    Returns in `*prop` the properties of device `dev`. The
-    :py:obj:`~.cudaDeviceProp` structure is defined as:
+    Returns in `*value` the integer value of the attribute `attr` on device
+    `device`. The supported attributes are:
 
-    **View CUDA Toolkit Documentation for a C++ code example**
+    - :py:obj:`~.cudaDevAttrMaxThreadsPerBlock`: Maximum number of threads
+      per block
 
-    where:
+    - :py:obj:`~.cudaDevAttrMaxBlockDimX`: Maximum x-dimension of a block
 
-    - :py:obj:`~.name[256]` is an ASCII string identifying the device.
+    - :py:obj:`~.cudaDevAttrMaxBlockDimY`: Maximum y-dimension of a block
 
-    - :py:obj:`~.uuid` is a 16-byte unique identifier.
+    - :py:obj:`~.cudaDevAttrMaxBlockDimZ`: Maximum z-dimension of a block
 
-    - :py:obj:`~.totalGlobalMem` is the total amount of global memory
-      available on the device in bytes.
+    - :py:obj:`~.cudaDevAttrMaxGridDimX`: Maximum x-dimension of a grid
 
-    - :py:obj:`~.sharedMemPerBlock` is the maximum amount of shared memory
-      available to a thread block in bytes.
+    - :py:obj:`~.cudaDevAttrMaxGridDimY`: Maximum y-dimension of a grid
 
-    - :py:obj:`~.regsPerBlock` is the maximum number of 32-bit registers
-      available to a thread block.
+    - :py:obj:`~.cudaDevAttrMaxGridDimZ`: Maximum z-dimension of a grid
 
-    - :py:obj:`~.warpSize` is the warp size in threads.
+    - :py:obj:`~.cudaDevAttrMaxSharedMemoryPerBlock`: Maximum amount of
+      shared memory available to a thread block in bytes
 
-    - :py:obj:`~.memPitch` is the maximum pitch in bytes allowed by the
-      memory copy functions that involve memory regions allocated through
-      :py:obj:`~.cudaMallocPitch()`.
+    - :py:obj:`~.cudaDevAttrTotalConstantMemory`: Memory available on
+      device for constant variables in a CUDA C kernel in bytes
 
-    - :py:obj:`~.maxThreadsPerBlock` is the maximum number of threads per
-      block.
+    - :py:obj:`~.cudaDevAttrWarpSize`: Warp size in threads
 
-    - :py:obj:`~.maxThreadsDim[3]` contains the maximum size of each
-      dimension of a block.
+    - :py:obj:`~.cudaDevAttrMaxPitch`: Maximum pitch in bytes allowed by
+      the memory copy functions that involve memory regions allocated
+      through :py:obj:`~.cudaMallocPitch()`
 
-    - :py:obj:`~.maxGridSize[3]` contains the maximum size of each
-      dimension of a grid.
+    - :py:obj:`~.cudaDevAttrMaxTexture1DWidth`: Maximum 1D texture width
 
-    - :py:obj:`~.clockRate` is the clock frequency in kilohertz.
+    - :py:obj:`~.cudaDevAttrMaxTexture1DLinearWidth`: Maximum width for a
+      1D texture bound to linear memory
 
-    - :py:obj:`~.totalConstMem` is the total amount of constant memory
-      available on the device in bytes.
+    - :py:obj:`~.cudaDevAttrMaxTexture1DMipmappedWidth`: Maximum mipmapped
+      1D texture width
 
-    - :py:obj:`~.major`, :py:obj:`~.minor` are the major and minor revision
-      numbers defining the device's compute capability.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DWidth`: Maximum 2D texture width
 
-    - :py:obj:`~.textureAlignment` is the alignment requirement; texture
-      base addresses that are aligned to :py:obj:`~.textureAlignment` bytes
-      do not need an offset applied to texture fetches.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DHeight`: Maximum 2D texture height
 
-    - :py:obj:`~.texturePitchAlignment` is the pitch alignment requirement
-      for 2D texture references that are bound to pitched memory.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearWidth`: Maximum width for a
+      2D texture bound to linear memory
 
-    - :py:obj:`~.deviceOverlap` is 1 if the device can concurrently copy
-      memory between host and device while executing a kernel, or 0 if not.
-      Deprecated, use instead asyncEngineCount.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearHeight`: Maximum height for a
+      2D texture bound to linear memory
 
-    - :py:obj:`~.multiProcessorCount` is the number of multiprocessors on
-      the device.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearPitch`: Maximum pitch in
+      bytes for a 2D texture bound to linear memory
 
-    - :py:obj:`~.kernelExecTimeoutEnabled` is 1 if there is a run time
-      limit for kernels executed on the device, or 0 if not.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DMipmappedWidth`: Maximum mipmapped
+      2D texture width
 
-    - :py:obj:`~.integrated` is 1 if the device is an integrated
-      (motherboard) GPU and 0 if it is a discrete (card) component.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DMipmappedHeight`: Maximum mipmapped
+      2D texture height
 
-    - :py:obj:`~.canMapHostMemory` is 1 if the device can map host memory
-      into the CUDA address space for use with
-      :py:obj:`~.cudaHostAlloc()`/:py:obj:`~.cudaHostGetDevicePointer()`,
-      or 0 if not.
+    - :py:obj:`~.cudaDevAttrMaxTexture3DWidth`: Maximum 3D texture width
 
-    - :py:obj:`~.computeMode` is the compute mode that the device is
-      currently in. Available modes are as follows:
+    - :py:obj:`~.cudaDevAttrMaxTexture3DHeight`: Maximum 3D texture height
 
-      - cudaComputeModeDefault: Default mode - Device is not restricted and
-        multiple threads can use :py:obj:`~.cudaSetDevice()` with this
-        device.
+    - :py:obj:`~.cudaDevAttrMaxTexture3DDepth`: Maximum 3D texture depth
 
-      - cudaComputeModeProhibited: Compute-prohibited mode - No threads can
-        use :py:obj:`~.cudaSetDevice()` with this device.
+    - :py:obj:`~.cudaDevAttrMaxTexture3DWidthAlt`: Alternate maximum 3D
+      texture width, 0 if no alternate maximum 3D texture size is supported
 
-      - cudaComputeModeExclusiveProcess: Compute-exclusive-process mode -
-        Many threads in one process will be able to use
-        :py:obj:`~.cudaSetDevice()` with this device.   When an occupied
-        exclusive mode device is chosen with :py:obj:`~.cudaSetDevice`, all
-        subsequent non-device management runtime functions will return
-        :py:obj:`~.cudaErrorDevicesUnavailable`.
+    - :py:obj:`~.cudaDevAttrMaxTexture3DHeightAlt`: Alternate maximum 3D
+      texture height, 0 if no alternate maximum 3D texture size is
+      supported
 
-    - :py:obj:`~.maxTexture1D` is the maximum 1D texture size.
+    - :py:obj:`~.cudaDevAttrMaxTexture3DDepthAlt`: Alternate maximum 3D
+      texture depth, 0 if no alternate maximum 3D texture size is supported
 
-    - :py:obj:`~.maxTexture1DMipmap` is the maximum 1D mipmapped texture
-      texture size.
+    - :py:obj:`~.cudaDevAttrMaxTextureCubemapWidth`: Maximum cubemap
+      texture width or height
 
-    - :py:obj:`~.maxTexture1DLinear` is the maximum 1D texture size for
-      textures bound to linear memory.
+    - :py:obj:`~.cudaDevAttrMaxTexture1DLayeredWidth`: Maximum 1D layered
+      texture width
 
-    - :py:obj:`~.maxTexture2D[2]` contains the maximum 2D texture
-      dimensions.
+    - :py:obj:`~.cudaDevAttrMaxTexture1DLayeredLayers`: Maximum layers in a
+      1D layered texture
 
-    - :py:obj:`~.maxTexture2DMipmap[2]` contains the maximum 2D mipmapped
-      texture dimensions.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredWidth`: Maximum 2D layered
+      texture width
 
-    - :py:obj:`~.maxTexture2DLinear[3]` contains the maximum 2D texture
-      dimensions for 2D textures bound to pitch linear memory.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredHeight`: Maximum 2D layered
+      texture height
 
-    - :py:obj:`~.maxTexture2DGather[2]` contains the maximum 2D texture
-      dimensions if texture gather operations have to be performed.
+    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredLayers`: Maximum layers in a
+      2D layered texture
 
-    - :py:obj:`~.maxTexture3D[3]` contains the maximum 3D texture
-      dimensions.
+    - :py:obj:`~.cudaDevAttrMaxTextureCubemapLayeredWidth`: Maximum cubemap
+      layered texture width or height
 
-    - :py:obj:`~.maxTexture3DAlt[3]` contains the maximum alternate 3D
-      texture dimensions.
+    - :py:obj:`~.cudaDevAttrMaxTextureCubemapLayeredLayers`: Maximum layers
+      in a cubemap layered texture
 
-    - :py:obj:`~.maxTextureCubemap` is the maximum cubemap texture width or
-      height.
+    - :py:obj:`~.cudaDevAttrMaxSurface1DWidth`: Maximum 1D surface width
 
-    - :py:obj:`~.maxTexture1DLayered[2]` contains the maximum 1D layered
-      texture dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface2DWidth`: Maximum 2D surface width
 
-    - :py:obj:`~.maxTexture2DLayered[3]` contains the maximum 2D layered
-      texture dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface2DHeight`: Maximum 2D surface height
 
-    - :py:obj:`~.maxTextureCubemapLayered[2]` contains the maximum cubemap
-      layered texture dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface3DWidth`: Maximum 3D surface width
 
-    - :py:obj:`~.maxSurface1D` is the maximum 1D surface size.
+    - :py:obj:`~.cudaDevAttrMaxSurface3DHeight`: Maximum 3D surface height
 
-    - :py:obj:`~.maxSurface2D[2]` contains the maximum 2D surface
-      dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface3DDepth`: Maximum 3D surface depth
 
-    - :py:obj:`~.maxSurface3D[3]` contains the maximum 3D surface
-      dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface1DLayeredWidth`: Maximum 1D layered
+      surface width
 
-    - :py:obj:`~.maxSurface1DLayered[2]` contains the maximum 1D layered
-      surface dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface1DLayeredLayers`: Maximum layers in a
+      1D layered surface
 
-    - :py:obj:`~.maxSurface2DLayered[3]` contains the maximum 2D layered
-      surface dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredWidth`: Maximum 2D layered
+      surface width
 
-    - :py:obj:`~.maxSurfaceCubemap` is the maximum cubemap surface width or
-      height.
+    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredHeight`: Maximum 2D layered
+      surface height
 
-    - :py:obj:`~.maxSurfaceCubemapLayered[2]` contains the maximum cubemap
-      layered surface dimensions.
+    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredLayers`: Maximum layers in a
+      2D layered surface
 
-    - :py:obj:`~.surfaceAlignment` specifies the alignment requirements for
-      surfaces.
+    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapWidth`: Maximum cubemap
+      surface width
 
-    - :py:obj:`~.concurrentKernels` is 1 if the device supports executing
-      multiple kernels within the same context simultaneously, or 0 if not.
-      It is not guaranteed that multiple kernels will be resident on the
-      device concurrently so this feature should not be relied upon for
-      correctness.
+    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapLayeredWidth`: Maximum cubemap
+      layered surface width
 
-    - :py:obj:`~.ECCEnabled` is 1 if the device has ECC support turned on,
-      or 0 if not.
+    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapLayeredLayers`: Maximum layers
+      in a cubemap layered surface
 
-    - :py:obj:`~.pciBusID` is the PCI bus identifier of the device.
+    - :py:obj:`~.cudaDevAttrMaxRegistersPerBlock`: Maximum number of 32-bit
+      registers available to a thread block
 
-    - :py:obj:`~.pciDeviceID` is the PCI device (sometimes called slot)
-      identifier of the device.
+    - :py:obj:`~.cudaDevAttrClockRate`: Peak clock frequency in kilohertz
 
-    - :py:obj:`~.pciDomainID` is the PCI domain identifier of the device.
+    - :py:obj:`~.cudaDevAttrTextureAlignment`: Alignment requirement;
+      texture base addresses aligned to :py:obj:`~.textureAlign` bytes do
+      not need an offset applied to texture fetches
 
-    - :py:obj:`~.tccDriver` is 1 if the device is using a TCC driver or 0
-      if not.
+    - :py:obj:`~.cudaDevAttrTexturePitchAlignment`: Pitch alignment
+      requirement for 2D texture references bound to pitched memory
 
-    - :py:obj:`~.asyncEngineCount` is 1 when the device can concurrently
-      copy memory between host and device while executing a kernel. It is 2
-      when the device can concurrently copy memory between host and device
-      in both directions and execute a kernel at the same time. It is 0 if
-      neither of these is supported.
+    - :py:obj:`~.cudaDevAttrGpuOverlap`: 1 if the device can concurrently
+      copy memory between host and device while executing a kernel, or 0 if
+      not
 
-    - :py:obj:`~.unifiedAddressing` is 1 if the device shares a unified
-      address space with the host and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrMultiProcessorCount`: Number of multiprocessors
+      on the device
 
-    - :py:obj:`~.memoryClockRate` is the peak memory clock frequency in
-      kilohertz.
+    - :py:obj:`~.cudaDevAttrKernelExecTimeout`: 1 if there is a run time
+      limit for kernels executed on the device, or 0 if not
 
-    - :py:obj:`~.memoryBusWidth` is the memory bus width   in bits.
+    - :py:obj:`~.cudaDevAttrIntegrated`: 1 if the device is integrated with
+      the memory subsystem, or 0 if not
 
-    - :py:obj:`~.l2CacheSize` is L2 cache size in bytes.
+    - :py:obj:`~.cudaDevAttrCanMapHostMemory`: 1 if the device can map host
+      memory into the CUDA address space, or 0 if not
 
-    - :py:obj:`~.persistingL2CacheMaxSize` is L2 cache's maximum persisting
-      lines size in bytes.
+    - :py:obj:`~.cudaDevAttrComputeMode`: Compute mode is the compute mode
+      that the device is currently in. Available modes are as follows:
 
-    - :py:obj:`~.maxThreadsPerMultiProcessor`   is the number of maximum
-      resident threads per multiprocessor.
+      - :py:obj:`~.cudaComputeModeDefault`: Default mode - Device is not
+        restricted and multiple threads can use :py:obj:`~.cudaSetDevice()`
+        with this device.
 
-    - :py:obj:`~.streamPrioritiesSupported` is 1 if the device supports
-      stream priorities, or 0 if it is not supported.
+      - :py:obj:`~.cudaComputeModeProhibited`: Compute-prohibited mode - No
+        threads can use :py:obj:`~.cudaSetDevice()` with this device.
 
-    - :py:obj:`~.globalL1CacheSupported` is 1 if the device supports
-      caching of globals in L1 cache, or 0 if it is not supported.
+      - :py:obj:`~.cudaComputeModeExclusiveProcess`: Compute-exclusive-
+        process mode - Many threads in one process will be able to use
+        :py:obj:`~.cudaSetDevice()` with this device.
 
-    - :py:obj:`~.localL1CacheSupported` is 1 if the device supports caching
-      of locals in L1 cache, or 0 if it is not supported.
+    - :py:obj:`~.cudaDevAttrConcurrentKernels`: 1 if the device supports
+      executing multiple kernels within the same context simultaneously, or
+      0 if not. It is not guaranteed that multiple kernels will be resident
+      on the device concurrently so this feature should not be relied upon
+      for correctness.
 
-    - :py:obj:`~.sharedMemPerMultiprocessor` is the maximum amount of
-      shared memory available to a multiprocessor in bytes; this amount is
-      shared by all thread blocks simultaneously resident on a
-      multiprocessor.
+    - :py:obj:`~.cudaDevAttrEccEnabled`: 1 if error correction is enabled
+      on the device, 0 if error correction is disabled or not supported by
+      the device
 
-    - :py:obj:`~.regsPerMultiprocessor` is the maximum number of 32-bit
-      registers available to a multiprocessor; this number is shared by all
-      thread blocks simultaneously resident on a multiprocessor.
+    - :py:obj:`~.cudaDevAttrPciBusId`: PCI bus identifier of the device
 
-    - :py:obj:`~.managedMemory` is 1 if the device supports allocating
-      managed memory on this system, or 0 if it is not supported.
+    - :py:obj:`~.cudaDevAttrPciDeviceId`: PCI device (also known as slot)
+      identifier of the device
 
-    - :py:obj:`~.isMultiGpuBoard` is 1 if the device is on a multi-GPU
-      board (e.g. Gemini cards), and 0 if not;
+    - :py:obj:`~.cudaDevAttrTccDriver`: 1 if the device is using a TCC
+      driver. TCC is only available on Tesla hardware running Windows Vista
+      or later.
 
-    - :py:obj:`~.multiGpuBoardGroupID` is a unique identifier for a group
-      of devices associated with the same board. Devices on the same multi-
-      GPU board will share the same identifier.
+    - :py:obj:`~.cudaDevAttrMemoryClockRate`: Peak memory clock frequency
+      in kilohertz
 
-    - :py:obj:`~.singleToDoublePrecisionPerfRatio`   is the ratio of single
-      precision performance (in floating-point operations per second) to
-      double precision performance.
+    - :py:obj:`~.cudaDevAttrGlobalMemoryBusWidth`: Global memory bus width
+      in bits
 
-    - :py:obj:`~.pageableMemoryAccess` is 1 if the device supports
-      coherently accessing pageable memory without calling cudaHostRegister
-      on it, and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrL2CacheSize`: Size of L2 cache in bytes. 0 if
+      the device doesn't have L2 cache.
 
-    - :py:obj:`~.concurrentManagedAccess` is 1 if the device can coherently
-      access managed memory concurrently with the CPU, and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrMaxThreadsPerMultiProcessor`: Maximum resident
+      threads per multiprocessor
 
-    - :py:obj:`~.computePreemptionSupported` is 1 if the device supports
-      Compute Preemption, and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrUnifiedAddressing`: 1 if the device shares a
+      unified address space with the host, or 0 if not
 
-    - :py:obj:`~.canUseHostPointerForRegisteredMem` is 1 if the device can
-      access host registered memory at the same virtual address as the CPU,
-      and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrComputeCapabilityMajor`: Major compute
+      capability version number
 
-    - :py:obj:`~.cooperativeLaunch` is 1 if the device supports launching
-      cooperative kernels via :py:obj:`~.cudaLaunchCooperativeKernel`, and
-      0 otherwise.
+    - :py:obj:`~.cudaDevAttrComputeCapabilityMinor`: Minor compute
+      capability version number
 
-    - :py:obj:`~.cooperativeMultiDeviceLaunch` is 1 if the device supports
-      launching cooperative kernels via
-      :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice`, and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrStreamPrioritiesSupported`: 1 if the device
+      supports stream priorities, or 0 if not
 
-    - :py:obj:`~.pageableMemoryAccessUsesHostPageTables` is 1 if the device
-      accesses pageable memory via the host's page tables, and 0 otherwise.
+    - :py:obj:`~.cudaDevAttrGlobalL1CacheSupported`: 1 if device supports
+      caching globals in L1 cache, 0 if not
 
-    - :py:obj:`~.directManagedMemAccessFromHost` is 1 if the host can
-      directly access managed memory on the device without migration, and 0
-      otherwise.
+    - :py:obj:`~.cudaDevAttrLocalL1CacheSupported`: 1 if device supports
+      caching locals in L1 cache, 0 if not
 
-    - :py:obj:`~.maxBlocksPerMultiProcessor` is the maximum number of
-      thread blocks that can reside on a multiprocessor.
+    - :py:obj:`~.cudaDevAttrMaxSharedMemoryPerMultiprocessor`: Maximum
+      amount of shared memory available to a multiprocessor in bytes; this
+      amount is shared by all thread blocks simultaneously resident on a
+      multiprocessor
 
-    - :py:obj:`~.accessPolicyMaxWindowSize` is the maximum value of
-      :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.
+    - :py:obj:`~.cudaDevAttrMaxRegistersPerMultiprocessor`: Maximum number
+      of 32-bit registers available to a multiprocessor; this number is
+      shared by all thread blocks simultaneously resident on a
+      multiprocessor
 
-    Parameters
-    ----------
-    device : int
-        Device number to get properties for
+    - :py:obj:`~.cudaDevAttrManagedMemory`: 1 if device supports allocating
+      managed memory, 0 if not
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
-    prop : :py:obj:`~.cudaDeviceProp`
-        Properties for the specified device
+    - :py:obj:`~.cudaDevAttrIsMultiGpuBoard`: 1 if device is on a multi-GPU
+      board, 0 if not
 
-    See Also
-    --------
-    :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cudaDeviceGetAttribute`, :py:obj:`~.cuDeviceGetAttribute`, :py:obj:`~.cuDeviceGetName`
-    """
-    cdef cudaDeviceProp prop = cudaDeviceProp()
-    err = ccudart.cudaGetDeviceProperties(prop._ptr, device)
-    return (cudaError_t(err), prop)
-{{endif}}
+    - :py:obj:`~.cudaDevAttrMultiGpuBoardGroupID`: Unique identifier for a
+      group of devices on the same multi-GPU board
 
-{{if 'cudaDeviceGetAttribute' in found_functions}}
+    - :py:obj:`~.cudaDevAttrHostNativeAtomicSupported`: 1 if the link
+      between the device and the host supports native atomic operations
 
-@cython.embedsignature(True)
-def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device):
-    """ Returns information about the device.
+    - :py:obj:`~.cudaDevAttrSingleToDoublePrecisionPerfRatio`: Ratio of
+      single precision performance (in floating-point operations per
+      second) to double precision performance
 
-    Returns in `*value` the integer value of the attribute `attr` on device
-    `device`. The supported attributes are:
+    - :py:obj:`~.cudaDevAttrPageableMemoryAccess`: 1 if the device supports
+      coherently accessing pageable memory without calling cudaHostRegister
+      on it, and 0 otherwise
 
-    - :py:obj:`~.cudaDevAttrMaxThreadsPerBlock`: Maximum number of threads
-      per block
+    - :py:obj:`~.cudaDevAttrConcurrentManagedAccess`: 1 if the device can
+      coherently access managed memory concurrently with the CPU, and 0
+      otherwise
 
-    - :py:obj:`~.cudaDevAttrMaxBlockDimX`: Maximum x-dimension of a block
+    - :py:obj:`~.cudaDevAttrComputePreemptionSupported`: 1 if the device
+      supports Compute Preemption, 0 if not
 
-    - :py:obj:`~.cudaDevAttrMaxBlockDimY`: Maximum y-dimension of a block
-
-    - :py:obj:`~.cudaDevAttrMaxBlockDimZ`: Maximum z-dimension of a block
-
-    - :py:obj:`~.cudaDevAttrMaxGridDimX`: Maximum x-dimension of a grid
-
-    - :py:obj:`~.cudaDevAttrMaxGridDimY`: Maximum y-dimension of a grid
-
-    - :py:obj:`~.cudaDevAttrMaxGridDimZ`: Maximum z-dimension of a grid
-
-    - :py:obj:`~.cudaDevAttrMaxSharedMemoryPerBlock`: Maximum amount of
-      shared memory available to a thread block in bytes
-
-    - :py:obj:`~.cudaDevAttrTotalConstantMemory`: Memory available on
-      device for constant variables in a CUDA C kernel in bytes
-
-    - :py:obj:`~.cudaDevAttrWarpSize`: Warp size in threads
-
-    - :py:obj:`~.cudaDevAttrMaxPitch`: Maximum pitch in bytes allowed by
-      the memory copy functions that involve memory regions allocated
-      through :py:obj:`~.cudaMallocPitch()`
-
-    - :py:obj:`~.cudaDevAttrMaxTexture1DWidth`: Maximum 1D texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture1DLinearWidth`: Maximum width for a
-      1D texture bound to linear memory
-
-    - :py:obj:`~.cudaDevAttrMaxTexture1DMipmappedWidth`: Maximum mipmapped
-      1D texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DWidth`: Maximum 2D texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DHeight`: Maximum 2D texture height
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearWidth`: Maximum width for a
-      2D texture bound to linear memory
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearHeight`: Maximum height for a
-      2D texture bound to linear memory
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLinearPitch`: Maximum pitch in
-      bytes for a 2D texture bound to linear memory
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DMipmappedWidth`: Maximum mipmapped
-      2D texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DMipmappedHeight`: Maximum mipmapped
-      2D texture height
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DWidth`: Maximum 3D texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DHeight`: Maximum 3D texture height
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DDepth`: Maximum 3D texture depth
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DWidthAlt`: Alternate maximum 3D
-      texture width, 0 if no alternate maximum 3D texture size is supported
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DHeightAlt`: Alternate maximum 3D
-      texture height, 0 if no alternate maximum 3D texture size is
-      supported
-
-    - :py:obj:`~.cudaDevAttrMaxTexture3DDepthAlt`: Alternate maximum 3D
-      texture depth, 0 if no alternate maximum 3D texture size is supported
-
-    - :py:obj:`~.cudaDevAttrMaxTextureCubemapWidth`: Maximum cubemap
-      texture width or height
-
-    - :py:obj:`~.cudaDevAttrMaxTexture1DLayeredWidth`: Maximum 1D layered
-      texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture1DLayeredLayers`: Maximum layers in a
-      1D layered texture
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredWidth`: Maximum 2D layered
-      texture width
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredHeight`: Maximum 2D layered
-      texture height
-
-    - :py:obj:`~.cudaDevAttrMaxTexture2DLayeredLayers`: Maximum layers in a
-      2D layered texture
-
-    - :py:obj:`~.cudaDevAttrMaxTextureCubemapLayeredWidth`: Maximum cubemap
-      layered texture width or height
-
-    - :py:obj:`~.cudaDevAttrMaxTextureCubemapLayeredLayers`: Maximum layers
-      in a cubemap layered texture
-
-    - :py:obj:`~.cudaDevAttrMaxSurface1DWidth`: Maximum 1D surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurface2DWidth`: Maximum 2D surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurface2DHeight`: Maximum 2D surface height
-
-    - :py:obj:`~.cudaDevAttrMaxSurface3DWidth`: Maximum 3D surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurface3DHeight`: Maximum 3D surface height
-
-    - :py:obj:`~.cudaDevAttrMaxSurface3DDepth`: Maximum 3D surface depth
-
-    - :py:obj:`~.cudaDevAttrMaxSurface1DLayeredWidth`: Maximum 1D layered
-      surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurface1DLayeredLayers`: Maximum layers in a
-      1D layered surface
-
-    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredWidth`: Maximum 2D layered
-      surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredHeight`: Maximum 2D layered
-      surface height
-
-    - :py:obj:`~.cudaDevAttrMaxSurface2DLayeredLayers`: Maximum layers in a
-      2D layered surface
-
-    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapWidth`: Maximum cubemap
-      surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapLayeredWidth`: Maximum cubemap
-      layered surface width
-
-    - :py:obj:`~.cudaDevAttrMaxSurfaceCubemapLayeredLayers`: Maximum layers
-      in a cubemap layered surface
-
-    - :py:obj:`~.cudaDevAttrMaxRegistersPerBlock`: Maximum number of 32-bit
-      registers available to a thread block
-
-    - :py:obj:`~.cudaDevAttrClockRate`: Peak clock frequency in kilohertz
-
-    - :py:obj:`~.cudaDevAttrTextureAlignment`: Alignment requirement;
-      texture base addresses aligned to :py:obj:`~.textureAlign` bytes do
-      not need an offset applied to texture fetches
-
-    - :py:obj:`~.cudaDevAttrTexturePitchAlignment`: Pitch alignment
-      requirement for 2D texture references bound to pitched memory
-
-    - :py:obj:`~.cudaDevAttrGpuOverlap`: 1 if the device can concurrently
-      copy memory between host and device while executing a kernel, or 0 if
-      not
-
-    - :py:obj:`~.cudaDevAttrMultiProcessorCount`: Number of multiprocessors
-      on the device
-
-    - :py:obj:`~.cudaDevAttrKernelExecTimeout`: 1 if there is a run time
-      limit for kernels executed on the device, or 0 if not
-
-    - :py:obj:`~.cudaDevAttrIntegrated`: 1 if the device is integrated with
-      the memory subsystem, or 0 if not
-
-    - :py:obj:`~.cudaDevAttrCanMapHostMemory`: 1 if the device can map host
-      memory into the CUDA address space, or 0 if not
-
-    - :py:obj:`~.cudaDevAttrComputeMode`: Compute mode is the compute mode
-      that the device is currently in. Available modes are as follows:
-
-      - :py:obj:`~.cudaComputeModeDefault`: Default mode - Device is not
-        restricted and multiple threads can use :py:obj:`~.cudaSetDevice()`
-        with this device.
-
-      - :py:obj:`~.cudaComputeModeProhibited`: Compute-prohibited mode - No
-        threads can use :py:obj:`~.cudaSetDevice()` with this device.
-
-      - :py:obj:`~.cudaComputeModeExclusiveProcess`: Compute-exclusive-
-        process mode - Many threads in one process will be able to use
-        :py:obj:`~.cudaSetDevice()` with this device.
-
-    - :py:obj:`~.cudaDevAttrConcurrentKernels`: 1 if the device supports
-      executing multiple kernels within the same context simultaneously, or
-      0 if not. It is not guaranteed that multiple kernels will be resident
-      on the device concurrently so this feature should not be relied upon
-      for correctness.
-
-    - :py:obj:`~.cudaDevAttrEccEnabled`: 1 if error correction is enabled
-      on the device, 0 if error correction is disabled or not supported by
-      the device
-
-    - :py:obj:`~.cudaDevAttrPciBusId`: PCI bus identifier of the device
-
-    - :py:obj:`~.cudaDevAttrPciDeviceId`: PCI device (also known as slot)
-      identifier of the device
-
-    - :py:obj:`~.cudaDevAttrTccDriver`: 1 if the device is using a TCC
-      driver. TCC is only available on Tesla hardware running Windows Vista
-      or later.
-
-    - :py:obj:`~.cudaDevAttrMemoryClockRate`: Peak memory clock frequency
-      in kilohertz
-
-    - :py:obj:`~.cudaDevAttrGlobalMemoryBusWidth`: Global memory bus width
-      in bits
-
-    - :py:obj:`~.cudaDevAttrL2CacheSize`: Size of L2 cache in bytes. 0 if
-      the device doesn't have L2 cache.
-
-    - :py:obj:`~.cudaDevAttrMaxThreadsPerMultiProcessor`: Maximum resident
-      threads per multiprocessor
-
-    - :py:obj:`~.cudaDevAttrUnifiedAddressing`: 1 if the device shares a
-      unified address space with the host, or 0 if not
-
-    - :py:obj:`~.cudaDevAttrComputeCapabilityMajor`: Major compute
-      capability version number
-
-    - :py:obj:`~.cudaDevAttrComputeCapabilityMinor`: Minor compute
-      capability version number
-
-    - :py:obj:`~.cudaDevAttrStreamPrioritiesSupported`: 1 if the device
-      supports stream priorities, or 0 if not
-
-    - :py:obj:`~.cudaDevAttrGlobalL1CacheSupported`: 1 if device supports
-      caching globals in L1 cache, 0 if not
-
-    - :py:obj:`~.cudaDevAttrLocalL1CacheSupported`: 1 if device supports
-      caching locals in L1 cache, 0 if not
-
-    - :py:obj:`~.cudaDevAttrMaxSharedMemoryPerMultiprocessor`: Maximum
-      amount of shared memory available to a multiprocessor in bytes; this
-      amount is shared by all thread blocks simultaneously resident on a
-      multiprocessor
-
-    - :py:obj:`~.cudaDevAttrMaxRegistersPerMultiprocessor`: Maximum number
-      of 32-bit registers available to a multiprocessor; this number is
-      shared by all thread blocks simultaneously resident on a
-      multiprocessor
-
-    - :py:obj:`~.cudaDevAttrManagedMemory`: 1 if device supports allocating
-      managed memory, 0 if not
-
-    - :py:obj:`~.cudaDevAttrIsMultiGpuBoard`: 1 if device is on a multi-GPU
-      board, 0 if not
-
-    - :py:obj:`~.cudaDevAttrMultiGpuBoardGroupID`: Unique identifier for a
-      group of devices on the same multi-GPU board
-
-    - :py:obj:`~.cudaDevAttrHostNativeAtomicSupported`: 1 if the link
-      between the device and the host supports native atomic operations
-
-    - :py:obj:`~.cudaDevAttrSingleToDoublePrecisionPerfRatio`: Ratio of
-      single precision performance (in floating-point operations per
-      second) to double precision performance
-
-    - :py:obj:`~.cudaDevAttrPageableMemoryAccess`: 1 if the device supports
-      coherently accessing pageable memory without calling cudaHostRegister
-      on it, and 0 otherwise
-
-    - :py:obj:`~.cudaDevAttrConcurrentManagedAccess`: 1 if the device can
-      coherently access managed memory concurrently with the CPU, and 0
-      otherwise
-
-    - :py:obj:`~.cudaDevAttrComputePreemptionSupported`: 1 if the device
-      supports Compute Preemption, 0 if not
-
-    - :py:obj:`~.cudaDevAttrCanUseHostPointerForRegisteredMem`: 1 if the
-      device can access host registered memory at the same virtual address
-      as the CPU, and 0 otherwise
+    - :py:obj:`~.cudaDevAttrCanUseHostPointerForRegisteredMem`: 1 if the
+      device can access host registered memory at the same virtual address
+      as the CPU, and 0 otherwise
 
     - :py:obj:`~.cudaDevAttrCooperativeLaunch`: 1 if the device supports
       launching cooperative kernels via
@@ -12191,8 +12155,8 @@ def cudaDeviceGetAttribute(attr not None : cudaDeviceAttr, int device):
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cuDeviceGetAttribute`
     """
     cdef int value = 0
-    cdef ccudart.cudaDeviceAttr cattr = attr.value
-    err = ccudart.cudaDeviceGetAttribute(&value, cattr, device)
+    cdef cyruntime.cudaDeviceAttr cyattr = attr.value
+    err = cyruntime.cudaDeviceGetAttribute(&value, cyattr, device)
     return (cudaError_t(err), value)
 {{endif}}
 
@@ -12223,7 +12187,8 @@ def cudaDeviceGetDefaultMemPool(int device):
     """
     cdef cudaMemPool_t memPool = cudaMemPool_t()
     with nogil:
-        err = ccudart.cudaDeviceGetDefaultMemPool(<ccudart.cudaMemPool_t*>memPool._ptr, device)
+        err = cyruntime.cudaDeviceGetDefaultMemPool(<cyruntime.cudaMemPool_t*>memPool._ptr, device)
+
     return (cudaError_t(err), memPool)
 {{endif}}
 
@@ -12259,18 +12224,18 @@ def cudaDeviceSetMemPool(int device, memPool):
     -----
     Use :py:obj:`~.cudaMallocFromPoolAsync` to specify asynchronous allocations from a device different than the one the stream runs on.
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     with nogil:
-        err = ccudart.cudaDeviceSetMemPool(device, cmemPool)
+        err = cyruntime.cudaDeviceSetMemPool(device, cymemPool)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12305,7 +12270,8 @@ def cudaDeviceGetMemPool(int device):
     """
     cdef cudaMemPool_t memPool = cudaMemPool_t()
     with nogil:
-        err = ccudart.cudaDeviceGetMemPool(<ccudart.cudaMemPool_t*>memPool._ptr, device)
+        err = cyruntime.cudaDeviceGetMemPool(<cyruntime.cudaMemPool_t*>memPool._ptr, device)
+
     return (cudaError_t(err), memPool)
 {{endif}}
 
@@ -12363,9 +12329,9 @@ def cudaDeviceGetNvSciSyncAttributes(nvSciSyncAttrList, int device, int flags):
     --------
     :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaDestroyExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cnvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
-    cdef void* cnvSciSyncAttrList_ptr = <void*><void_ptr>cnvSciSyncAttrList.cptr
-    err = ccudart.cudaDeviceGetNvSciSyncAttributes(cnvSciSyncAttrList_ptr, device, flags)
+    cynvSciSyncAttrList = utils.HelperInputVoidPtr(nvSciSyncAttrList)
+    cdef void* cynvSciSyncAttrList_ptr = <void*><void_ptr>cynvSciSyncAttrList.cptr
+    err = cyruntime.cudaDeviceGetNvSciSyncAttributes(cynvSciSyncAttrList_ptr, device, flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12421,8 +12387,8 @@ def cudaDeviceGetP2PAttribute(attr not None : cudaDeviceP2PAttr, int srcDevice,
     :py:obj:`~.cudaCtxEnablePeerAccess`, :py:obj:`~.cudaCtxDisablePeerAccess`, :py:obj:`~.cudaCtxCanAccessPeer`, :py:obj:`~.cuDeviceGetP2PAttribute`
     """
     cdef int value = 0
-    cdef ccudart.cudaDeviceP2PAttr cattr = attr.value
-    err = ccudart.cudaDeviceGetP2PAttribute(&value, cattr, srcDevice, dstDevice)
+    cdef cyruntime.cudaDeviceP2PAttr cyattr = attr.value
+    err = cyruntime.cudaDeviceGetP2PAttribute(&value, cyattr, srcDevice, dstDevice)
     return (cudaError_t(err), value)
 {{endif}}
 
@@ -12452,8 +12418,8 @@ def cudaChooseDevice(prop : Optional[cudaDeviceProp]):
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaGetDeviceProperties`
     """
     cdef int device = 0
-    cdef ccudart.cudaDeviceProp* cprop_ptr = prop._ptr if prop != None else NULL
-    err = ccudart.cudaChooseDevice(&device, cprop_ptr)
+    cdef cyruntime.cudaDeviceProp* cyprop_ptr = prop._ptr if prop != None else NULL
+    err = cyruntime.cudaChooseDevice(&device, cyprop_ptr)
     return (cudaError_t(err), device)
 {{endif}}
 
@@ -12505,7 +12471,7 @@ def cudaSetDevice(int device):
     --------
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuCtxSetCurrent`
     """
-    err = ccudart.cudaSetDevice(device)
+    err = cyruntime.cudaSetDevice(device)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12530,7 +12496,7 @@ def cudaGetDevice():
     :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuCtxGetCurrent`
     """
     cdef int device = 0
-    err = ccudart.cudaGetDevice(&device)
+    err = cyruntime.cudaGetDevice(&device)
     return (cudaError_t(err), device)
 {{endif}}
 
@@ -12610,7 +12576,7 @@ def cudaSetDeviceFlags(unsigned int flags):
     --------
     :py:obj:`~.cudaGetDeviceFlags`, :py:obj:`~.cudaGetDeviceCount`, :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaSetValidDevices`, :py:obj:`~.cudaChooseDevice`, :py:obj:`~.cuDevicePrimaryCtxSetFlags`
     """
-    err = ccudart.cudaSetDeviceFlags(flags)
+    err = cyruntime.cudaSetDeviceFlags(flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12657,7 +12623,7 @@ def cudaGetDeviceFlags():
     :py:obj:`~.cudaGetDevice`, :py:obj:`~.cudaGetDeviceProperties`, :py:obj:`~.cudaSetDevice`, :py:obj:`~.cudaSetDeviceFlags`, :py:obj:`~.cuCtxGetFlags`, :py:obj:`~.cuDevicePrimaryCtxGetState`
     """
     cdef unsigned int flags = 0
-    err = ccudart.cudaGetDeviceFlags(&flags)
+    err = cyruntime.cudaGetDeviceFlags(&flags)
     return (cudaError_t(err), flags)
 {{endif}}
 
@@ -12681,7 +12647,7 @@ def cudaStreamCreate():
     :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamGetPriority`, :py:obj:`~.cudaStreamGetFlags`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cuStreamCreate`
     """
     cdef cudaStream_t pStream = cudaStream_t()
-    err = ccudart.cudaStreamCreate(<ccudart.cudaStream_t*>pStream._ptr)
+    err = cyruntime.cudaStreamCreate(<cyruntime.cudaStream_t*>pStream._ptr)
     return (cudaError_t(err), pStream)
 {{endif}}
 
@@ -12718,7 +12684,7 @@ def cudaStreamCreateWithFlags(unsigned int flags):
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaStreamGetFlags`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cuStreamCreate`
     """
     cdef cudaStream_t pStream = cudaStream_t()
-    err = ccudart.cudaStreamCreateWithFlags(<ccudart.cudaStream_t*>pStream._ptr, flags)
+    err = cyruntime.cudaStreamCreateWithFlags(<cyruntime.cudaStream_t*>pStream._ptr, flags)
     return (cudaError_t(err), pStream)
 {{endif}}
 
@@ -12771,7 +12737,7 @@ def cudaStreamCreateWithPriority(unsigned int flags, int priority):
     In the current implementation, only compute kernels launched in priority streams are affected by the stream's priority. Stream priorities have no effect on host-to-device and device-to-host memory operations.
     """
     cdef cudaStream_t pStream = cudaStream_t()
-    err = ccudart.cudaStreamCreateWithPriority(<ccudart.cudaStream_t*>pStream._ptr, flags, priority)
+    err = cyruntime.cudaStreamCreateWithPriority(<cyruntime.cudaStream_t*>pStream._ptr, flags, priority)
     return (cudaError_t(err), pStream)
 {{endif}}
 
@@ -12805,18 +12771,17 @@ def cudaStreamGetPriority(hStream):
     --------
     :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaDeviceGetStreamPriorityRange`, :py:obj:`~.cudaStreamGetFlags`, :py:obj:`~.cuStreamGetPriority`
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef int priority = 0
-    err = ccudart.cudaStreamGetPriority(chStream, &priority)
+    err = cyruntime.cudaStreamGetPriority(cyhStream, &priority)
     return (cudaError_t(err), priority)
 {{endif}}
 
@@ -12846,18 +12811,17 @@ def cudaStreamGetFlags(hStream):
     --------
     :py:obj:`~.cudaStreamCreateWithPriority`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamGetPriority`, :py:obj:`~.cuStreamGetFlags`
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef unsigned int flags = 0
-    err = ccudart.cudaStreamGetFlags(chStream, &flags)
+    err = cyruntime.cudaStreamGetFlags(cyhStream, &flags)
     return (cudaError_t(err), flags)
 {{endif}}
 
@@ -12879,7 +12843,7 @@ def cudaCtxResetPersistingL2Cache():
     --------
     :py:obj:`~.cudaAccessPolicyWindow`
     """
-    err = ccudart.cudaCtxResetPersistingL2Cache()
+    err = cyruntime.cudaCtxResetPersistingL2Cache()
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12908,27 +12872,25 @@ def cudaStreamCopyAttributes(dst, src):
     --------
     :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef ccudart.cudaStream_t csrc
+    cdef cyruntime.cudaStream_t cysrc
     if src is None:
-        csrc = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(src, (cudaStream_t,cuda.CUstream)):
+        cysrc = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(src, (cudaStream_t,driver.CUstream)):
         psrc = int(src)
-        csrc = <ccudart.cudaStream_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaStream_t><void_ptr>psrc
     else:
         psrc = int(cudaStream_t(src))
-        csrc = <ccudart.cudaStream_t><void_ptr>psrc
-
-    cdef ccudart.cudaStream_t cdst
+        cysrc = <cyruntime.cudaStream_t><void_ptr>psrc
+    cdef cyruntime.cudaStream_t cydst
     if dst is None:
-        cdst = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(dst, (cudaStream_t,cuda.CUstream)):
+        cydst = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(dst, (cudaStream_t,driver.CUstream)):
         pdst = int(dst)
-        cdst = <ccudart.cudaStream_t><void_ptr>pdst
+        cydst = <cyruntime.cudaStream_t><void_ptr>pdst
     else:
         pdst = int(cudaStream_t(dst))
-        cdst = <ccudart.cudaStream_t><void_ptr>pdst
-
-    err = ccudart.cudaStreamCopyAttributes(cdst, csrc)
+        cydst = <cyruntime.cudaStream_t><void_ptr>pdst
+    err = cyruntime.cudaStreamCopyAttributes(cydst, cysrc)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -12959,26 +12921,25 @@ def cudaStreamGetAttribute(hStream, attr not None : cudaStreamAttrID):
     --------
     :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
-    cdef ccudart.cudaStreamAttrID cattr = attr.value
-    cdef cudaLaunchAttributeValue value_out = cudaLaunchAttributeValue()
-    err = ccudart.cudaStreamGetAttribute(chStream, cattr, value_out._ptr)
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
+    cdef cyruntime.cudaStreamAttrID cyattr = attr.value
+    cdef cudaStreamAttrValue value_out = cudaStreamAttrValue()
+    err = cyruntime.cudaStreamGetAttribute(cyhStream, cyattr, <cyruntime.cudaStreamAttrValue*>value_out._ptr)
     return (cudaError_t(err), value_out)
 {{endif}}
 
 {{if 'cudaStreamSetAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Optional[cudaLaunchAttributeValue]):
+def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Optional[cudaStreamAttrValue]):
     """ Sets stream attribute.
 
     Sets attribute `attr` on `hStream` from corresponding attribute of
@@ -13003,19 +12964,18 @@ def cudaStreamSetAttribute(hStream, attr not None : cudaStreamAttrID, value : Op
     --------
     :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
-    cdef ccudart.cudaStreamAttrID cattr = attr.value
-    cdef ccudart.cudaStreamAttrValue* cvalue_ptr = value._ptr if value != None else NULL
-    err = ccudart.cudaStreamSetAttribute(chStream, cattr, cvalue_ptr)
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
+    cdef cyruntime.cudaStreamAttrID cyattr = attr.value
+    cdef cyruntime.cudaStreamAttrValue* cyvalue_ptr = value._ptr if value != None else NULL
+    err = cyruntime.cudaStreamSetAttribute(cyhStream, cyattr, cyvalue_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13046,17 +13006,16 @@ def cudaStreamDestroy(stream):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cuStreamDestroy`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    err = ccudart.cudaStreamDestroy(cstream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    err = cyruntime.cudaStreamDestroy(cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13097,28 +13056,27 @@ def cudaStreamWaitEvent(stream, event, unsigned int flags):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cuStreamWaitEvent`
     """
-    cdef ccudart.cudaEvent_t cevent
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    cdef ccudart.cudaStream_t cstream
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     with nogil:
-        err = ccudart.cudaStreamWaitEvent(cstream, cevent, flags)
+        err = cyruntime.cudaStreamWaitEvent(cystream, cyevent, flags)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13193,30 +13151,29 @@ def cudaStreamAddCallback(stream, callback, userData, unsigned int flags):
     -----
     This function is slated for eventual deprecation and removal. If you do not require the callback to execute in case of a device error, consider using :py:obj:`~.cudaLaunchHostFunc`. Additionally, this function is not supported with :py:obj:`~.cudaStreamBeginCapture` and :py:obj:`~.cudaStreamEndCapture`, unlike :py:obj:`~.cudaLaunchHostFunc`.
     """
-    cdef ccudart.cudaStreamCallback_t ccallback
+    cdef cyruntime.cudaStreamCallback_t cycallback
     if callback is None:
-        ccallback = <ccudart.cudaStreamCallback_t><void_ptr>0
-    elif isinstance(callback, (cudaStreamCallback_t)):
+        cycallback = <cyruntime.cudaStreamCallback_t><void_ptr>0
+    elif isinstance(callback, (cudaStreamCallback_t,)):
         pcallback = int(callback)
-        ccallback = <ccudart.cudaStreamCallback_t><void_ptr>pcallback
+        cycallback = <cyruntime.cudaStreamCallback_t><void_ptr>pcallback
     else:
         pcallback = int(cudaStreamCallback_t(callback))
-        ccallback = <ccudart.cudaStreamCallback_t><void_ptr>pcallback
-
-    cdef ccudart.cudaStream_t cstream
+        cycallback = <cyruntime.cudaStreamCallback_t><void_ptr>pcallback
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cuserData = utils.HelperInputVoidPtr(userData)
-    cdef void* cuserData_ptr = <void*><void_ptr>cuserData.cptr
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cyuserData = utils.HelperInputVoidPtr(userData)
+    cdef void* cyuserData_ptr = <void*><void_ptr>cyuserData.cptr
     with nogil:
-        err = ccudart.cudaStreamAddCallback(cstream, ccallback, cuserData_ptr, flags)
+        err = cyruntime.cudaStreamAddCallback(cystream, cycallback, cyuserData_ptr, flags)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13245,18 +13202,18 @@ def cudaStreamSynchronize(stream):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cuStreamSynchronize`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     with nogil:
-        err = ccudart.cudaStreamSynchronize(cstream)
+        err = cyruntime.cudaStreamSynchronize(cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13287,17 +13244,16 @@ def cudaStreamQuery(stream):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cuStreamQuery`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    err = ccudart.cudaStreamQuery(cstream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    err = cyruntime.cudaStreamQuery(cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13397,19 +13353,18 @@ def cudaStreamAttachMemAsync(stream, devPtr, size_t length, unsigned int flags):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamCreateWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cudaMallocManaged`, :py:obj:`~.cuStreamAttachMemAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaStreamAttachMemAsync(cstream, cdevPtr_ptr, length, flags)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaStreamAttachMemAsync(cystream, cydevPtr_ptr, length, flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13456,18 +13411,17 @@ def cudaStreamBeginCapture(stream, mode not None : cudaStreamCaptureMode):
     -----
     Kernels captured using this API must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaStreamCaptureMode cmode = mode.value
-    err = ccudart.cudaStreamBeginCapture(cstream, cmode)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaStreamCaptureMode cymode = mode.value
+    err = cyruntime.cudaStreamBeginCapture(cystream, cymode)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13537,9 +13491,9 @@ def cudaThreadExchangeStreamCaptureMode(mode not None : cudaStreamCaptureMode):
     --------
     :py:obj:`~.cudaStreamBeginCapture`
     """
-    cdef ccudart.cudaStreamCaptureMode cmode = mode.value
-    err = ccudart.cudaThreadExchangeStreamCaptureMode(&cmode)
-    return (cudaError_t(err), cudaStreamCaptureMode(cmode))
+    cdef cyruntime.cudaStreamCaptureMode cymode = mode.value
+    err = cyruntime.cudaThreadExchangeStreamCaptureMode(&cymode)
+    return (cudaError_t(err), cudaStreamCaptureMode(cymode))
 {{endif}}
 
 {{if 'cudaStreamEndCapture' in found_functions}}
@@ -13574,18 +13528,17 @@ def cudaStreamEndCapture(stream):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamBeginCapture`, :py:obj:`~.cudaStreamIsCapturing`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     cdef cudaGraph_t pGraph = cudaGraph_t()
-    err = ccudart.cudaStreamEndCapture(cstream, <ccudart.cudaGraph_t*>pGraph._ptr)
+    err = cyruntime.cudaStreamEndCapture(cystream, <cyruntime.cudaGraph_t*>pGraph._ptr)
     return (cudaError_t(err), pGraph)
 {{endif}}
 
@@ -13635,18 +13588,17 @@ def cudaStreamIsCapturing(stream):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamBeginCapture`, :py:obj:`~.cudaStreamEndCapture`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaStreamCaptureStatus pCaptureStatus
-    err = ccudart.cudaStreamIsCapturing(cstream, &pCaptureStatus)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaStreamCaptureStatus pCaptureStatus
+    err = cyruntime.cudaStreamIsCapturing(cystream, &pCaptureStatus)
     return (cudaError_t(err), cudaStreamCaptureStatus(pCaptureStatus))
 {{endif}}
 
@@ -13691,19 +13643,18 @@ def cudaStreamGetCaptureInfo(stream):
     --------
     :py:obj:`~.cudaStreamGetCaptureInfo_v2`, :py:obj:`~.cudaStreamBeginCapture`, :py:obj:`~.cudaStreamIsCapturing`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaStreamCaptureStatus pCaptureStatus
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaStreamCaptureStatus pCaptureStatus
     cdef unsigned long long pId = 0
-    err = ccudart.cudaStreamGetCaptureInfo(cstream, &pCaptureStatus, &pId)
+    err = cyruntime.cudaStreamGetCaptureInfo(cystream, &pCaptureStatus, &pId)
     return (cudaError_t(err), cudaStreamCaptureStatus(pCaptureStatus), pId)
 {{endif}}
 
@@ -13779,32 +13730,31 @@ def cudaStreamGetCaptureInfo_v2(stream):
     --------
     :py:obj:`~.cudaStreamGetCaptureInfo`, :py:obj:`~.cudaStreamBeginCapture`, :py:obj:`~.cudaStreamIsCapturing`, :py:obj:`~.cudaStreamUpdateCaptureDependencies`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaStreamCaptureStatus captureStatus_out
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaStreamCaptureStatus captureStatus_out
     cdef unsigned long long id_out = 0
     cdef cudaGraph_t graph_out = cudaGraph_t()
-    cdef const ccudart.cudaGraphNode_t* cdependencies_out = NULL
+    cdef const cyruntime.cudaGraphNode_t* cydependencies_out = NULL
     pydependencies_out = []
     cdef size_t numDependencies_out = 0
-    err = ccudart.cudaStreamGetCaptureInfo_v2(cstream, &captureStatus_out, &id_out, <ccudart.cudaGraph_t*>graph_out._ptr, &cdependencies_out, &numDependencies_out)
+    err = cyruntime.cudaStreamGetCaptureInfo_v2(cystream, &captureStatus_out, &id_out, <cyruntime.cudaGraph_t*>graph_out._ptr, &cydependencies_out, &numDependencies_out)
     if cudaError_t(err) == cudaError_t(0):
-        pydependencies_out = [cudaGraphNode_t(init_value=<void_ptr>cdependencies_out[idx]) for idx in range(numDependencies_out)]
+        pydependencies_out = [cudaGraphNode_t(init_value=<void_ptr>cydependencies_out[idx]) for idx in range(numDependencies_out)]
     return (cudaError_t(err), cudaStreamCaptureStatus(captureStatus_out), id_out, graph_out, pydependencies_out, numDependencies_out)
 {{endif}}
 
 {{if 'cudaStreamUpdateCaptureDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, unsigned int flags):
+def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, unsigned int flags):
     """ Update the set of dependencies in a capturing stream (11.3+)
 
     Modifies the dependency set of a capturing stream. The dependency set
@@ -13849,32 +13799,29 @@ def cudaStreamUpdateCaptureDependencies(stream, dependencies : Optional[List[cud
     :py:obj:`~.cudaStreamBeginCapture`, :py:obj:`~.cudaStreamGetCaptureInfo`, :py:obj:`~.cudaStreamGetCaptureInfo_v2`
     """
     dependencies = [] if dependencies is None else dependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in dependencies):
-        raise TypeError("Argument 'dependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaStream_t cstream
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in dependencies):
+        raise TypeError("Argument 'dependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaGraphNode_t* cdependencies = NULL
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaGraphNode_t* cydependencies = NULL
     if len(dependencies) > 0:
-        cdependencies = <ccudart.cudaGraphNode_t*> calloc(len(dependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cdependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cydependencies = <cyruntime.cudaGraphNode_t*> calloc(len(dependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cydependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(dependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(dependencies)):
-                cdependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>dependencies[idx])._ptr[0]
-
+                cydependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>dependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(dependencies): raise RuntimeError("List is too small: " + str(len(dependencies)) + " < " + str(numDependencies))
-    err = ccudart.cudaStreamUpdateCaptureDependencies(cstream, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>dependencies[0])._ptr if len(dependencies) == 1 else cdependencies, numDependencies, flags)
-    if cdependencies is not NULL:
-        free(cdependencies)
+    err = cyruntime.cudaStreamUpdateCaptureDependencies(cystream, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>dependencies[0])._ptr if len(dependencies) == 1 else cydependencies, numDependencies, flags)
+    if cydependencies is not NULL:
+        free(cydependencies)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -13899,7 +13846,7 @@ def cudaEventCreate():
     cudaEventCreate (C++ API), :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cuEventCreate`
     """
     cdef cudaEvent_t event = cudaEvent_t()
-    err = ccudart.cudaEventCreate(<ccudart.cudaEvent_t*>event._ptr)
+    err = cyruntime.cudaEventCreate(<cyruntime.cudaEvent_t*>event._ptr)
     return (cudaError_t(err), event)
 {{endif}}
 
@@ -13948,7 +13895,7 @@ def cudaEventCreateWithFlags(unsigned int flags):
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cuEventCreate`
     """
     cdef cudaEvent_t event = cudaEvent_t()
-    err = ccudart.cudaEventCreateWithFlags(<ccudart.cudaEvent_t*>event._ptr, flags)
+    err = cyruntime.cudaEventCreateWithFlags(<cyruntime.cudaEvent_t*>event._ptr, flags)
     return (cudaError_t(err), event)
 {{endif}}
 
@@ -13990,27 +13937,25 @@ def cudaEventRecord(event, stream):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cuEventRecord`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaEvent_t cevent
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    err = ccudart.cudaEventRecord(cevent, cstream)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    err = cyruntime.cudaEventRecord(cyevent, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14061,27 +14006,25 @@ def cudaEventRecordWithFlags(event, stream, unsigned int flags):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cuEventRecord`,
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaEvent_t cevent
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    err = ccudart.cudaEventRecordWithFlags(cevent, cstream, flags)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    err = cyruntime.cudaEventRecordWithFlags(cyevent, cystream, flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14117,17 +14060,16 @@ def cudaEventQuery(event):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cuEventQuery`
     """
-    cdef ccudart.cudaEvent_t cevent
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    err = ccudart.cudaEventQuery(cevent)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    err = cyruntime.cudaEventQuery(cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14162,17 +14104,16 @@ def cudaEventSynchronize(event):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cuEventSynchronize`
     """
-    cdef ccudart.cudaEvent_t cevent
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    err = ccudart.cudaEventSynchronize(cevent)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    err = cyruntime.cudaEventSynchronize(cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14204,17 +14145,16 @@ def cudaEventDestroy(event):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cudaEventElapsedTime`, :py:obj:`~.cuEventDestroy`
     """
-    cdef ccudart.cudaEvent_t cevent
+    cdef cyruntime.cudaEvent_t cyevent
     if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
         pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
         pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    err = ccudart.cudaEventDestroy(cevent)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    err = cyruntime.cudaEventDestroy(cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14263,28 +14203,26 @@ def cudaEventElapsedTime(start, end):
     --------
     :py:obj:`~.cudaEventCreate (C API)`, :py:obj:`~.cudaEventCreateWithFlags`, :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`, :py:obj:`~.cudaEventRecord`, :py:obj:`~.cuEventElapsedTime`
     """
-    cdef ccudart.cudaEvent_t cend
+    cdef cyruntime.cudaEvent_t cyend
     if end is None:
-        cend = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(end, (cudaEvent_t,cuda.CUevent)):
+        cyend = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(end, (cudaEvent_t,driver.CUevent)):
         pend = int(end)
-        cend = <ccudart.cudaEvent_t><void_ptr>pend
+        cyend = <cyruntime.cudaEvent_t><void_ptr>pend
     else:
         pend = int(cudaEvent_t(end))
-        cend = <ccudart.cudaEvent_t><void_ptr>pend
-
-    cdef ccudart.cudaEvent_t cstart
+        cyend = <cyruntime.cudaEvent_t><void_ptr>pend
+    cdef cyruntime.cudaEvent_t cystart
     if start is None:
-        cstart = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(start, (cudaEvent_t,cuda.CUevent)):
+        cystart = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(start, (cudaEvent_t,driver.CUevent)):
         pstart = int(start)
-        cstart = <ccudart.cudaEvent_t><void_ptr>pstart
+        cystart = <cyruntime.cudaEvent_t><void_ptr>pstart
     else:
         pstart = int(cudaEvent_t(start))
-        cstart = <ccudart.cudaEvent_t><void_ptr>pstart
-
+        cystart = <cyruntime.cudaEvent_t><void_ptr>pstart
     cdef float ms = 0
-    err = ccudart.cudaEventElapsedTime(&ms, cstart, cend)
+    err = cyruntime.cudaEventElapsedTime(&ms, cystart, cyend)
     return (cudaError_t(err), ms)
 {{endif}}
 
@@ -14434,8 +14372,8 @@ def cudaImportExternalMemory(memHandleDesc : Optional[cudaExternalMemoryHandleDe
     and Cache Control" chapter from Vulkan specification.
     """
     cdef cudaExternalMemory_t extMem_out = cudaExternalMemory_t()
-    cdef ccudart.cudaExternalMemoryHandleDesc* cmemHandleDesc_ptr = memHandleDesc._ptr if memHandleDesc != None else NULL
-    err = ccudart.cudaImportExternalMemory(extMem_out._ptr, cmemHandleDesc_ptr)
+    cdef cyruntime.cudaExternalMemoryHandleDesc* cymemHandleDesc_ptr = memHandleDesc._ptr if memHandleDesc != None else NULL
+    err = cyruntime.cudaImportExternalMemory(<cyruntime.cudaExternalMemory_t*>extMem_out._ptr, cymemHandleDesc_ptr)
     return (cudaError_t(err), extMem_out)
 {{endif}}
 
@@ -14490,19 +14428,18 @@ def cudaExternalMemoryGetMappedBuffer(extMem, bufferDesc : Optional[cudaExternal
     --------
     :py:obj:`~.cudaImportExternalMemory`, :py:obj:`~.cudaDestroyExternalMemory`, :py:obj:`~.cudaExternalMemoryGetMappedMipmappedArray`
     """
-    cdef ccudart.cudaExternalMemory_t cextMem
+    cdef cyruntime.cudaExternalMemory_t cyextMem
     if extMem is None:
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>0
-    elif isinstance(extMem, (cudaExternalMemory_t)):
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>0
+    elif isinstance(extMem, (cudaExternalMemory_t,)):
         pextMem = int(extMem)
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     else:
         pextMem = int(cudaExternalMemory_t(extMem))
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
-
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     cdef void_ptr devPtr = 0
-    cdef ccudart.cudaExternalMemoryBufferDesc* cbufferDesc_ptr = bufferDesc._ptr if bufferDesc != None else NULL
-    err = ccudart.cudaExternalMemoryGetMappedBuffer(<void**>&devPtr, cextMem, cbufferDesc_ptr)
+    cdef cyruntime.cudaExternalMemoryBufferDesc* cybufferDesc_ptr = bufferDesc._ptr if bufferDesc != None else NULL
+    err = cyruntime.cudaExternalMemoryGetMappedBuffer(<void**>&devPtr, cyextMem, cybufferDesc_ptr)
     return (cudaError_t(err), devPtr)
 {{endif}}
 
@@ -14563,19 +14500,18 @@ def cudaExternalMemoryGetMappedMipmappedArray(extMem, mipmapDesc : Optional[cuda
 
     If :py:obj:`~.cudaExternalMemoryHandleDesc.type` is :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, then :py:obj:`~.cudaExternalMemoryMipmappedArrayDesc.numLevels` must not be greater than 1.
     """
-    cdef ccudart.cudaExternalMemory_t cextMem
+    cdef cyruntime.cudaExternalMemory_t cyextMem
     if extMem is None:
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>0
-    elif isinstance(extMem, (cudaExternalMemory_t)):
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>0
+    elif isinstance(extMem, (cudaExternalMemory_t,)):
         pextMem = int(extMem)
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     else:
         pextMem = int(cudaExternalMemory_t(extMem))
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
-
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     cdef cudaMipmappedArray_t mipmap = cudaMipmappedArray_t()
-    cdef ccudart.cudaExternalMemoryMipmappedArrayDesc* cmipmapDesc_ptr = mipmapDesc._ptr if mipmapDesc != None else NULL
-    err = ccudart.cudaExternalMemoryGetMappedMipmappedArray(mipmap._ptr, cextMem, cmipmapDesc_ptr)
+    cdef cyruntime.cudaExternalMemoryMipmappedArrayDesc* cymipmapDesc_ptr = mipmapDesc._ptr if mipmapDesc != None else NULL
+    err = cyruntime.cudaExternalMemoryGetMappedMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmap._ptr, cyextMem, cymipmapDesc_ptr)
     return (cudaError_t(err), mipmap)
 {{endif}}
 
@@ -14604,17 +14540,16 @@ def cudaDestroyExternalMemory(extMem):
     --------
     :py:obj:`~.cudaImportExternalMemory`, :py:obj:`~.cudaExternalMemoryGetMappedBuffer`, :py:obj:`~.cudaExternalMemoryGetMappedMipmappedArray`
     """
-    cdef ccudart.cudaExternalMemory_t cextMem
+    cdef cyruntime.cudaExternalMemory_t cyextMem
     if extMem is None:
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>0
-    elif isinstance(extMem, (cudaExternalMemory_t)):
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>0
+    elif isinstance(extMem, (cudaExternalMemory_t,)):
         pextMem = int(extMem)
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
     else:
         pextMem = int(cudaExternalMemory_t(extMem))
-        cextMem = <ccudart.cudaExternalMemory_t><void_ptr>pextMem
-
-    err = ccudart.cudaDestroyExternalMemory(cextMem)
+        cyextMem = <cyruntime.cudaExternalMemory_t><void_ptr>pextMem
+    err = cyruntime.cudaDestroyExternalMemory(cyextMem)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -14759,15 +14694,15 @@ def cudaImportExternalSemaphore(semHandleDesc : Optional[cudaExternalSemaphoreHa
     :py:obj:`~.cudaDestroyExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
     cdef cudaExternalSemaphore_t extSem_out = cudaExternalSemaphore_t()
-    cdef ccudart.cudaExternalSemaphoreHandleDesc* csemHandleDesc_ptr = semHandleDesc._ptr if semHandleDesc != None else NULL
-    err = ccudart.cudaImportExternalSemaphore(extSem_out._ptr, csemHandleDesc_ptr)
+    cdef cyruntime.cudaExternalSemaphoreHandleDesc* cysemHandleDesc_ptr = semHandleDesc._ptr if semHandleDesc != None else NULL
+    err = cyruntime.cudaImportExternalSemaphore(<cyruntime.cudaExternalSemaphore_t*>extSem_out._ptr, cysemHandleDesc_ptr)
     return (cudaError_t(err), extSem_out)
 {{endif}}
 
 {{if 'cudaSignalExternalSemaphoresAsync_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[List[cudaExternalSemaphore_t]], paramsArray : Optional[List[cudaExternalSemaphoreSignalParams]], unsigned int numExtSems, stream):
+def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[Tuple[cudaExternalSemaphore_t] | List[cudaExternalSemaphore_t]], paramsArray : Optional[Tuple[cudaExternalSemaphoreSignalParams] | List[cudaExternalSemaphoreSignalParams]], unsigned int numExtSems, stream):
     """ Signals a set of external semaphore objects.
 
     Enqueues a signal operation on a set of externally allocated semaphore
@@ -14840,55 +14775,50 @@ def cudaSignalExternalSemaphoresAsync(extSemArray : Optional[List[cudaExternalSe
     --------
     :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaDestroyExternalSemaphore`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     paramsArray = [] if paramsArray is None else paramsArray
-    if not all(isinstance(_x, (cudaExternalSemaphoreSignalParams)) for _x in paramsArray):
-        raise TypeError("Argument 'paramsArray' is not instance of type (expected List[ccudart.cudaExternalSemaphoreSignalParams]")
-
+    if not all(isinstance(_x, (cudaExternalSemaphoreSignalParams,)) for _x in paramsArray):
+        raise TypeError("Argument 'paramsArray' is not instance of type (expected Tuple[cyruntime.cudaExternalSemaphoreSignalParams,] or List[cyruntime.cudaExternalSemaphoreSignalParams,]")
     extSemArray = [] if extSemArray is None else extSemArray
-    if not all(isinstance(_x, (cudaExternalSemaphore_t)) for _x in extSemArray):
-        raise TypeError("Argument 'extSemArray' is not instance of type (expected List[ccudart.cudaExternalSemaphore_t]")
-
-    cdef ccudart.cudaExternalSemaphore_t* cextSemArray = NULL
+    if not all(isinstance(_x, (cudaExternalSemaphore_t,)) for _x in extSemArray):
+        raise TypeError("Argument 'extSemArray' is not instance of type (expected Tuple[cyruntime.cudaExternalSemaphore_t,] or List[cyruntime.cudaExternalSemaphore_t,]")
+    cdef cyruntime.cudaExternalSemaphore_t* cyextSemArray = NULL
     if len(extSemArray) > 0:
-        cextSemArray = <ccudart.cudaExternalSemaphore_t*> calloc(len(extSemArray), sizeof(ccudart.cudaExternalSemaphore_t))
-        if cextSemArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphore_t)))
+        cyextSemArray = <cyruntime.cudaExternalSemaphore_t*> calloc(len(extSemArray), sizeof(cyruntime.cudaExternalSemaphore_t))
+        if cyextSemArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphore_t)))
         else:
             for idx in range(len(extSemArray)):
-                cextSemArray[idx] = (<cudaExternalSemaphore_t>extSemArray[idx])._ptr[0]
-
-    cdef ccudart.cudaExternalSemaphoreSignalParams* cparamsArray = NULL
+                cyextSemArray[idx] = <cyruntime.cudaExternalSemaphore_t>(<cudaExternalSemaphore_t>extSemArray[idx])._ptr[0]
+    cdef cyruntime.cudaExternalSemaphoreSignalParams* cyparamsArray = NULL
     if len(paramsArray) > 0:
-        cparamsArray = <ccudart.cudaExternalSemaphoreSignalParams*> calloc(len(paramsArray), sizeof(ccudart.cudaExternalSemaphoreSignalParams))
-        if cparamsArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphoreSignalParams)))
+        cyparamsArray = <cyruntime.cudaExternalSemaphoreSignalParams*> calloc(len(paramsArray), sizeof(cyruntime.cudaExternalSemaphoreSignalParams))
+        if cyparamsArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphoreSignalParams)))
         for idx in range(len(paramsArray)):
-            memcpy(&cparamsArray[idx], (<cudaExternalSemaphoreSignalParams>paramsArray[idx])._ptr, sizeof(ccudart.cudaExternalSemaphoreSignalParams))
-
+            string.memcpy(&cyparamsArray[idx], (<cudaExternalSemaphoreSignalParams>paramsArray[idx])._ptr, sizeof(cyruntime.cudaExternalSemaphoreSignalParams))
     if numExtSems > len(extSemArray): raise RuntimeError("List is too small: " + str(len(extSemArray)) + " < " + str(numExtSems))
     if numExtSems > len(paramsArray): raise RuntimeError("List is too small: " + str(len(paramsArray)) + " < " + str(numExtSems))
-    err = ccudart.cudaSignalExternalSemaphoresAsync((<cudaExternalSemaphore_t>extSemArray[0])._ptr if len(extSemArray) == 1 else cextSemArray, (<cudaExternalSemaphoreSignalParams>paramsArray[0])._ptr if len(paramsArray) == 1 else cparamsArray, numExtSems, cstream)
-    if cextSemArray is not NULL:
-        free(cextSemArray)
-    if cparamsArray is not NULL:
-        free(cparamsArray)
+    err = cyruntime.cudaSignalExternalSemaphoresAsync(<cyruntime.cudaExternalSemaphore_t*>(<cudaExternalSemaphore_t>extSemArray[0])._ptr if len(extSemArray) == 1 else cyextSemArray, (<cudaExternalSemaphoreSignalParams>paramsArray[0])._ptr if len(paramsArray) == 1 else cyparamsArray, numExtSems, cystream)
+    if cyextSemArray is not NULL:
+        free(cyextSemArray)
+    if cyparamsArray is not NULL:
+        free(cyparamsArray)
     return (cudaError_t(err),)
 {{endif}}
 
 {{if 'cudaWaitExternalSemaphoresAsync_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[List[cudaExternalSemaphore_t]], paramsArray : Optional[List[cudaExternalSemaphoreWaitParams]], unsigned int numExtSems, stream):
+def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[Tuple[cudaExternalSemaphore_t] | List[cudaExternalSemaphore_t]], paramsArray : Optional[Tuple[cudaExternalSemaphoreWaitParams] | List[cudaExternalSemaphoreWaitParams]], unsigned int numExtSems, stream):
     """ Waits on a set of external semaphore objects.
 
     Enqueues a wait operation on a set of externally allocated semaphore
@@ -14970,48 +14900,43 @@ def cudaWaitExternalSemaphoresAsync(extSemArray : Optional[List[cudaExternalSema
     --------
     :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaDestroyExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     paramsArray = [] if paramsArray is None else paramsArray
-    if not all(isinstance(_x, (cudaExternalSemaphoreWaitParams)) for _x in paramsArray):
-        raise TypeError("Argument 'paramsArray' is not instance of type (expected List[ccudart.cudaExternalSemaphoreWaitParams]")
-
+    if not all(isinstance(_x, (cudaExternalSemaphoreWaitParams,)) for _x in paramsArray):
+        raise TypeError("Argument 'paramsArray' is not instance of type (expected Tuple[cyruntime.cudaExternalSemaphoreWaitParams,] or List[cyruntime.cudaExternalSemaphoreWaitParams,]")
     extSemArray = [] if extSemArray is None else extSemArray
-    if not all(isinstance(_x, (cudaExternalSemaphore_t)) for _x in extSemArray):
-        raise TypeError("Argument 'extSemArray' is not instance of type (expected List[ccudart.cudaExternalSemaphore_t]")
-
-    cdef ccudart.cudaExternalSemaphore_t* cextSemArray = NULL
+    if not all(isinstance(_x, (cudaExternalSemaphore_t,)) for _x in extSemArray):
+        raise TypeError("Argument 'extSemArray' is not instance of type (expected Tuple[cyruntime.cudaExternalSemaphore_t,] or List[cyruntime.cudaExternalSemaphore_t,]")
+    cdef cyruntime.cudaExternalSemaphore_t* cyextSemArray = NULL
     if len(extSemArray) > 0:
-        cextSemArray = <ccudart.cudaExternalSemaphore_t*> calloc(len(extSemArray), sizeof(ccudart.cudaExternalSemaphore_t))
-        if cextSemArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphore_t)))
+        cyextSemArray = <cyruntime.cudaExternalSemaphore_t*> calloc(len(extSemArray), sizeof(cyruntime.cudaExternalSemaphore_t))
+        if cyextSemArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(extSemArray)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphore_t)))
         else:
             for idx in range(len(extSemArray)):
-                cextSemArray[idx] = (<cudaExternalSemaphore_t>extSemArray[idx])._ptr[0]
-
-    cdef ccudart.cudaExternalSemaphoreWaitParams* cparamsArray = NULL
+                cyextSemArray[idx] = <cyruntime.cudaExternalSemaphore_t>(<cudaExternalSemaphore_t>extSemArray[idx])._ptr[0]
+    cdef cyruntime.cudaExternalSemaphoreWaitParams* cyparamsArray = NULL
     if len(paramsArray) > 0:
-        cparamsArray = <ccudart.cudaExternalSemaphoreWaitParams*> calloc(len(paramsArray), sizeof(ccudart.cudaExternalSemaphoreWaitParams))
-        if cparamsArray is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(ccudart.cudaExternalSemaphoreWaitParams)))
+        cyparamsArray = <cyruntime.cudaExternalSemaphoreWaitParams*> calloc(len(paramsArray), sizeof(cyruntime.cudaExternalSemaphoreWaitParams))
+        if cyparamsArray is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(paramsArray)) + 'x' + str(sizeof(cyruntime.cudaExternalSemaphoreWaitParams)))
         for idx in range(len(paramsArray)):
-            memcpy(&cparamsArray[idx], (<cudaExternalSemaphoreWaitParams>paramsArray[idx])._ptr, sizeof(ccudart.cudaExternalSemaphoreWaitParams))
-
+            string.memcpy(&cyparamsArray[idx], (<cudaExternalSemaphoreWaitParams>paramsArray[idx])._ptr, sizeof(cyruntime.cudaExternalSemaphoreWaitParams))
     if numExtSems > len(extSemArray): raise RuntimeError("List is too small: " + str(len(extSemArray)) + " < " + str(numExtSems))
     if numExtSems > len(paramsArray): raise RuntimeError("List is too small: " + str(len(paramsArray)) + " < " + str(numExtSems))
-    err = ccudart.cudaWaitExternalSemaphoresAsync((<cudaExternalSemaphore_t>extSemArray[0])._ptr if len(extSemArray) == 1 else cextSemArray, (<cudaExternalSemaphoreWaitParams>paramsArray[0])._ptr if len(paramsArray) == 1 else cparamsArray, numExtSems, cstream)
-    if cextSemArray is not NULL:
-        free(cextSemArray)
-    if cparamsArray is not NULL:
-        free(cparamsArray)
+    err = cyruntime.cudaWaitExternalSemaphoresAsync(<cyruntime.cudaExternalSemaphore_t*>(<cudaExternalSemaphore_t>extSemArray[0])._ptr if len(extSemArray) == 1 else cyextSemArray, (<cudaExternalSemaphoreWaitParams>paramsArray[0])._ptr if len(paramsArray) == 1 else cyparamsArray, numExtSems, cystream)
+    if cyextSemArray is not NULL:
+        free(cyextSemArray)
+    if cyparamsArray is not NULL:
+        free(cyparamsArray)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15039,17 +14964,16 @@ def cudaDestroyExternalSemaphore(extSem):
     --------
     :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaExternalSemaphore_t cextSem
+    cdef cyruntime.cudaExternalSemaphore_t cyextSem
     if extSem is None:
-        cextSem = <ccudart.cudaExternalSemaphore_t><void_ptr>0
-    elif isinstance(extSem, (cudaExternalSemaphore_t)):
+        cyextSem = <cyruntime.cudaExternalSemaphore_t><void_ptr>0
+    elif isinstance(extSem, (cudaExternalSemaphore_t,)):
         pextSem = int(extSem)
-        cextSem = <ccudart.cudaExternalSemaphore_t><void_ptr>pextSem
+        cyextSem = <cyruntime.cudaExternalSemaphore_t><void_ptr>pextSem
     else:
         pextSem = int(cudaExternalSemaphore_t(extSem))
-        cextSem = <ccudart.cudaExternalSemaphore_t><void_ptr>pextSem
-
-    err = ccudart.cudaDestroyExternalSemaphore(cextSem)
+        cyextSem = <cyruntime.cudaExternalSemaphore_t><void_ptr>pextSem
+    err = cyruntime.cudaDestroyExternalSemaphore(cyextSem)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15108,10 +15032,10 @@ def cudaFuncSetCacheConfig(func, cacheConfig not None : cudaFuncCache):
     --------
     cudaFuncSetCacheConfig (C++ API), :py:obj:`~.cudaFuncGetAttributes (C API)`, :py:obj:`~.cudaLaunchKernel (C API)`, :py:obj:`~.cudaThreadGetCacheConfig`, :py:obj:`~.cudaThreadSetCacheConfig`, :py:obj:`~.cuFuncSetCacheConfig`
     """
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    cdef ccudart.cudaFuncCache ccacheConfig = cacheConfig.value
-    err = ccudart.cudaFuncSetCacheConfig(cfunc_ptr, ccacheConfig)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    cdef cyruntime.cudaFuncCache cycacheConfig = cacheConfig.value
+    err = cyruntime.cudaFuncSetCacheConfig(cyfunc_ptr, cycacheConfig)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15173,10 +15097,10 @@ def cudaFuncSetSharedMemConfig(func, config not None : cudaSharedMemConfig):
     --------
     :py:obj:`~.cudaDeviceSetSharedMemConfig`, :py:obj:`~.cudaDeviceGetSharedMemConfig`, :py:obj:`~.cudaDeviceSetCacheConfig`, :py:obj:`~.cudaDeviceGetCacheConfig`, :py:obj:`~.cudaFuncSetCacheConfig`, :py:obj:`~.cuFuncSetSharedMemConfig`
     """
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    cdef ccudart.cudaSharedMemConfig cconfig = config.value
-    err = ccudart.cudaFuncSetSharedMemConfig(cfunc_ptr, cconfig)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    cdef cyruntime.cudaSharedMemConfig cyconfig = config.value
+    err = cyruntime.cudaFuncSetSharedMemConfig(cyfunc_ptr, cyconfig)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15215,9 +15139,9 @@ def cudaFuncGetAttributes(func):
     :py:obj:`~.cudaFuncSetCacheConfig (C API)`, cudaFuncGetAttributes (C++ API), :py:obj:`~.cudaLaunchKernel (C API)`, :py:obj:`~.cuFuncGetAttribute`
     """
     cdef cudaFuncAttributes attr = cudaFuncAttributes()
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    err = ccudart.cudaFuncGetAttributes(attr._ptr, cfunc_ptr)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    err = cyruntime.cudaFuncGetAttributes(<cyruntime.cudaFuncAttributes*>attr._ptr, cyfunc_ptr)
     return (cudaError_t(err), attr)
 {{endif}}
 
@@ -15270,70 +15194,10 @@ def cudaFuncSetAttribute(func, attr not None : cudaFuncAttribute, int value):
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDeviceFunction`, :py:obj:`~.cudaErrorInvalidValue`
     """
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    cdef ccudart.cudaFuncAttribute cattr = attr.value
-    err = ccudart.cudaFuncSetAttribute(cfunc_ptr, cattr, value)
-    return (cudaError_t(err),)
-{{endif}}
-
-{{if 'cudaSetDoubleForDevice' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaSetDoubleForDevice(double d):
-    """ Converts a double argument to be executed on a device.
-
-    [Deprecated]
-
-    Converts the double value of `d` to an internal float representation if
-    the device does not support double arithmetic. If the device does
-    natively support doubles, then this function does nothing.
-
-    Parameters
-    ----------
-    d : double
-        Double to convert
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`
-
-    See Also
-    --------
-    :py:obj:`~.cudaFuncSetCacheConfig (C API)`, :py:obj:`~.cudaFuncGetAttributes (C API)`, :py:obj:`~.cudaSetDoubleForHost`
-    """
-    err = ccudart.cudaSetDoubleForDevice(&d)
-    return (cudaError_t(err),)
-{{endif}}
-
-{{if 'cudaSetDoubleForHost' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaSetDoubleForHost(double d):
-    """ Converts a double argument after execution on a device.
-
-    [Deprecated]
-
-    Converts the double value of `d` from a potentially internal float
-    representation if the device does not support double arithmetic. If the
-    device does natively support doubles, then this function does nothing.
-
-    Parameters
-    ----------
-    d : double
-        Double to convert
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`
-
-    See Also
-    --------
-    :py:obj:`~.cudaFuncSetCacheConfig (C API)`, :py:obj:`~.cudaFuncGetAttributes (C API)`, :py:obj:`~.cudaSetDoubleForDevice`
-    """
-    err = ccudart.cudaSetDoubleForHost(&d)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    cdef cyruntime.cudaFuncAttribute cyattr = attr.value
+    err = cyruntime.cudaFuncSetAttribute(cyfunc_ptr, cyattr, value)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15401,30 +15265,29 @@ def cudaLaunchHostFunc(stream, fn, userData):
     --------
     :py:obj:`~.cudaStreamCreate`, :py:obj:`~.cudaStreamQuery`, :py:obj:`~.cudaStreamSynchronize`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaStreamDestroy`, :py:obj:`~.cudaMallocManaged`, :py:obj:`~.cudaStreamAttachMemAsync`, :py:obj:`~.cudaStreamAddCallback`, :py:obj:`~.cuLaunchHostFunc`
     """
-    cdef ccudart.cudaHostFn_t cfn
+    cdef cyruntime.cudaHostFn_t cyfn
     if fn is None:
-        cfn = <ccudart.cudaHostFn_t><void_ptr>0
-    elif isinstance(fn, (cudaHostFn_t)):
+        cyfn = <cyruntime.cudaHostFn_t><void_ptr>0
+    elif isinstance(fn, (cudaHostFn_t,)):
         pfn = int(fn)
-        cfn = <ccudart.cudaHostFn_t><void_ptr>pfn
+        cyfn = <cyruntime.cudaHostFn_t><void_ptr>pfn
     else:
         pfn = int(cudaHostFn_t(fn))
-        cfn = <ccudart.cudaHostFn_t><void_ptr>pfn
-
-    cdef ccudart.cudaStream_t cstream
+        cyfn = <cyruntime.cudaHostFn_t><void_ptr>pfn
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cuserData = utils.HelperInputVoidPtr(userData)
-    cdef void* cuserData_ptr = <void*><void_ptr>cuserData.cptr
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cyuserData = utils.HelperInputVoidPtr(userData)
+    cdef void* cyuserData_ptr = <void*><void_ptr>cyuserData.cptr
     with nogil:
-        err = ccudart.cudaLaunchHostFunc(cstream, cfn, cuserData_ptr)
+        err = cyruntime.cudaLaunchHostFunc(cystream, cyfn, cyuserData_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15458,9 +15321,9 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessor(func, int blockSize, size_t dy
     :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`, cudaOccupancyMaxPotentialBlockSize (C++ API), cudaOccupancyMaxPotentialBlockSizeWithFlags (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMem (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags (C++ API), cudaOccupancyAvailableDynamicSMemPerBlock (C++ API), :py:obj:`~.cuOccupancyMaxActiveBlocksPerMultiprocessor`
     """
     cdef int numBlocks = 0
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    err = ccudart.cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cfunc_ptr, blockSize, dynamicSMemSize)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    err = cyruntime.cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, cyfunc_ptr, blockSize, dynamicSMemSize)
     return (cudaError_t(err), numBlocks)
 {{endif}}
 
@@ -15494,9 +15357,9 @@ def cudaOccupancyAvailableDynamicSMemPerBlock(func, int numBlocks, int blockSize
     :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`, cudaOccupancyMaxPotentialBlockSize (C++ API), cudaOccupancyMaxPotentialBlockSizeWithFlags (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMem (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags (C++ API), :py:obj:`~.cudaOccupancyAvailableDynamicSMemPerBlock`
     """
     cdef size_t dynamicSmemSize = 0
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    err = ccudart.cudaOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cfunc_ptr, numBlocks, blockSize)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    err = cyruntime.cudaOccupancyAvailableDynamicSMemPerBlock(&dynamicSmemSize, cyfunc_ptr, numBlocks, blockSize)
     return (cudaError_t(err), dynamicSmemSize)
 {{endif}}
 
@@ -15547,9 +15410,9 @@ def cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(func, int blockSize,
     :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessor`, cudaOccupancyMaxPotentialBlockSize (C++ API), cudaOccupancyMaxPotentialBlockSizeWithFlags (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMem (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags (C++ API), cudaOccupancyAvailableDynamicSMemPerBlock (C++ API), :py:obj:`~.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags`
     """
     cdef int numBlocks = 0
-    cfunc = utils.HelperInputVoidPtr(func)
-    cdef void* cfunc_ptr = <void*><void_ptr>cfunc.cptr
-    err = ccudart.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cfunc_ptr, blockSize, dynamicSMemSize, flags)
+    cyfunc = utils.HelperInputVoidPtr(func)
+    cdef void* cyfunc_ptr = <void*><void_ptr>cyfunc.cptr
+    err = cyruntime.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(&numBlocks, cyfunc_ptr, blockSize, dynamicSMemSize, flags)
     return (cudaError_t(err), numBlocks)
 {{endif}}
 
@@ -15681,7 +15544,8 @@ def cudaMallocManaged(size_t size, unsigned int flags):
     """
     cdef void_ptr devPtr = 0
     with nogil:
-        err = ccudart.cudaMallocManaged(<void**>&devPtr, size, flags)
+        err = cyruntime.cudaMallocManaged(<void**>&devPtr, size, flags)
+
     return (cudaError_t(err), devPtr)
 {{endif}}
 
@@ -15718,7 +15582,8 @@ def cudaMalloc(size_t size):
     """
     cdef void_ptr devPtr = 0
     with nogil:
-        err = ccudart.cudaMalloc(<void**>&devPtr, size)
+        err = cyruntime.cudaMalloc(<void**>&devPtr, size)
+
     return (cudaError_t(err), devPtr)
 {{endif}}
 
@@ -15757,7 +15622,7 @@ def cudaMallocHost(size_t size):
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaFreeArray`, cudaMallocHost (C++ API), :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMemAllocHost`
     """
     cdef void_ptr ptr = 0
-    err = ccudart.cudaMallocHost(<void**>&ptr, size)
+    err = cyruntime.cudaMallocHost(<void**>&ptr, size)
     return (cudaError_t(err), ptr)
 {{endif}}
 
@@ -15810,7 +15675,7 @@ def cudaMallocPitch(size_t width, size_t height):
     """
     cdef void_ptr devPtr = 0
     cdef size_t pitch = 0
-    err = ccudart.cudaMallocPitch(<void**>&devPtr, &pitch, width, height)
+    err = cyruntime.cudaMallocPitch(<void**>&devPtr, &pitch, width, height)
     return (cudaError_t(err), devPtr, pitch)
 {{endif}}
 
@@ -15883,9 +15748,10 @@ def cudaMallocArray(desc : Optional[cudaChannelFormatDesc], size_t width, size_t
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuArrayCreate`
     """
     cdef cudaArray_t array = cudaArray_t()
-    cdef ccudart.cudaChannelFormatDesc* cdesc_ptr = desc._ptr if desc != None else NULL
+    cdef cyruntime.cudaChannelFormatDesc* cydesc_ptr = desc._ptr if desc != None else NULL
     with nogil:
-        err = ccudart.cudaMallocArray(array._ptr, cdesc_ptr, width, height, flags)
+        err = cyruntime.cudaMallocArray(<cyruntime.cudaArray_t*>array._ptr, cydesc_ptr, width, height, flags)
+
     return (cudaError_t(err), array)
 {{endif}}
 
@@ -15931,10 +15797,11 @@ def cudaFree(devPtr):
     --------
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaMallocManaged`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaMallocFromPoolAsync` :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaFreeAsync` :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMemFree`
     """
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     with nogil:
-        err = ccudart.cudaFree(cdevPtr_ptr)
+        err = cyruntime.cudaFree(cydevPtr_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15962,10 +15829,11 @@ def cudaFreeHost(ptr):
     --------
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMemFreeHost`
     """
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     with nogil:
-        err = ccudart.cudaFreeHost(cptr_ptr)
+        err = cyruntime.cudaFreeHost(cyptr_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -15993,18 +15861,18 @@ def cudaFreeArray(array):
     --------
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuArrayDestroy`
     """
-    cdef ccudart.cudaArray_t carray
+    cdef cyruntime.cudaArray_t cyarray
     if array is None:
-        carray = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(array, (cudaArray_t)):
+        cyarray = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(array, (cudaArray_t,)):
         parray = int(array)
-        carray = <ccudart.cudaArray_t><void_ptr>parray
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     else:
         parray = int(cudaArray_t(array))
-        carray = <ccudart.cudaArray_t><void_ptr>parray
-
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     with nogil:
-        err = ccudart.cudaFreeArray(carray)
+        err = cyruntime.cudaFreeArray(cyarray)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16032,17 +15900,16 @@ def cudaFreeMipmappedArray(mipmappedArray):
     --------
     :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMipmappedArrayDestroy`
     """
-    cdef ccudart.cudaMipmappedArray_t cmipmappedArray
+    cdef cyruntime.cudaMipmappedArray_t cymipmappedArray
     if mipmappedArray is None:
-        cmipmappedArray = <ccudart.cudaMipmappedArray_t><void_ptr>0
-    elif isinstance(mipmappedArray, (cudaMipmappedArray_t)):
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_t><void_ptr>0
+    elif isinstance(mipmappedArray, (cudaMipmappedArray_t,)):
         pmipmappedArray = int(mipmappedArray)
-        cmipmappedArray = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmappedArray
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmappedArray
     else:
         pmipmappedArray = int(cudaMipmappedArray_t(mipmappedArray))
-        cmipmappedArray = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmappedArray
-
-    err = ccudart.cudaFreeMipmappedArray(cmipmappedArray)
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmappedArray
+    err = cyruntime.cudaFreeMipmappedArray(cymipmappedArray)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16125,7 +15992,8 @@ def cudaHostAlloc(size_t size, unsigned int flags):
     """
     cdef void_ptr pHost = 0
     with nogil:
-        err = ccudart.cudaHostAlloc(<void**>&pHost, size, flags)
+        err = cyruntime.cudaHostAlloc(<void**>&pHost, size, flags)
+
     return (cudaError_t(err), pHost)
 {{endif}}
 
@@ -16234,10 +16102,11 @@ def cudaHostRegister(ptr, size_t size, unsigned int flags):
     --------
     :py:obj:`~.cudaHostUnregister`, :py:obj:`~.cudaHostGetFlags`, :py:obj:`~.cudaHostGetDevicePointer`, :py:obj:`~.cuMemHostRegister`
     """
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     with nogil:
-        err = ccudart.cudaHostRegister(cptr_ptr, size, flags)
+        err = cyruntime.cudaHostRegister(cyptr_ptr, size, flags)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16267,10 +16136,11 @@ def cudaHostUnregister(ptr):
     --------
     :py:obj:`~.cudaHostUnregister`, :py:obj:`~.cuMemHostUnregister`
     """
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
     with nogil:
-        err = ccudart.cudaHostUnregister(cptr_ptr)
+        err = cyruntime.cudaHostUnregister(cyptr_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16327,9 +16197,9 @@ def cudaHostGetDevicePointer(pHost, unsigned int flags):
     :py:obj:`~.cudaSetDeviceFlags`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMemHostGetDevicePointer`
     """
     cdef void_ptr pDevice = 0
-    cpHost = utils.HelperInputVoidPtr(pHost)
-    cdef void* cpHost_ptr = <void*><void_ptr>cpHost.cptr
-    err = ccudart.cudaHostGetDevicePointer(<void**>&pDevice, cpHost_ptr, flags)
+    cypHost = utils.HelperInputVoidPtr(pHost)
+    cdef void* cypHost_ptr = <void*><void_ptr>cypHost.cptr
+    err = cyruntime.cudaHostGetDevicePointer(<void**>&pDevice, cypHost_ptr, flags)
     return (cudaError_t(err), pDevice)
 {{endif}}
 
@@ -16359,9 +16229,9 @@ def cudaHostGetFlags(pHost):
     :py:obj:`~.cudaHostAlloc`, :py:obj:`~.cuMemHostGetFlags`
     """
     cdef unsigned int pFlags = 0
-    cpHost = utils.HelperInputVoidPtr(pHost)
-    cdef void* cpHost_ptr = <void*><void_ptr>cpHost.cptr
-    err = ccudart.cudaHostGetFlags(&pFlags, cpHost_ptr)
+    cypHost = utils.HelperInputVoidPtr(pHost)
+    cdef void* cypHost_ptr = <void*><void_ptr>cypHost.cptr
+    err = cyruntime.cudaHostGetFlags(&pFlags, cypHost_ptr)
     return (cudaError_t(err), pFlags)
 {{endif}}
 
@@ -16407,7 +16277,7 @@ def cudaMalloc3D(extent not None : cudaExtent):
     :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaMallocArray`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.make_cudaPitchedPtr`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.cuMemAllocPitch`
     """
     cdef cudaPitchedPtr pitchedDevPtr = cudaPitchedPtr()
-    err = ccudart.cudaMalloc3D(pitchedDevPtr._ptr, extent._ptr[0])
+    err = cyruntime.cudaMalloc3D(<cyruntime.cudaPitchedPtr*>pitchedDevPtr._ptr, extent._ptr[0])
     return (cudaError_t(err), pitchedDevPtr)
 {{endif}}
 
@@ -16526,9 +16396,10 @@ def cudaMalloc3DArray(desc : Optional[cudaChannelFormatDesc], extent not None :
     :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.cuArray3DCreate`
     """
     cdef cudaArray_t array = cudaArray_t()
-    cdef ccudart.cudaChannelFormatDesc* cdesc_ptr = desc._ptr if desc != None else NULL
+    cdef cyruntime.cudaChannelFormatDesc* cydesc_ptr = desc._ptr if desc != None else NULL
     with nogil:
-        err = ccudart.cudaMalloc3DArray(array._ptr, cdesc_ptr, extent._ptr[0], flags)
+        err = cyruntime.cudaMalloc3DArray(<cyruntime.cudaArray_t*>array._ptr, cydesc_ptr, extent._ptr[0], flags)
+
     return (cudaError_t(err), array)
 {{endif}}
 
@@ -16650,8 +16521,8 @@ def cudaMallocMipmappedArray(desc : Optional[cudaChannelFormatDesc], extent not
     :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.cuMipmappedArrayCreate`
     """
     cdef cudaMipmappedArray_t mipmappedArray = cudaMipmappedArray_t()
-    cdef ccudart.cudaChannelFormatDesc* cdesc_ptr = desc._ptr if desc != None else NULL
-    err = ccudart.cudaMallocMipmappedArray(mipmappedArray._ptr, cdesc_ptr, extent._ptr[0], numLevels, flags)
+    cdef cyruntime.cudaChannelFormatDesc* cydesc_ptr = desc._ptr if desc != None else NULL
+    err = cyruntime.cudaMallocMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmappedArray._ptr, cydesc_ptr, extent._ptr[0], numLevels, flags)
     return (cudaError_t(err), mipmappedArray)
 {{endif}}
 
@@ -16688,18 +16559,17 @@ def cudaGetMipmappedArrayLevel(mipmappedArray, unsigned int level):
     --------
     :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc`, :py:obj:`~.cudaMallocPitch`, :py:obj:`~.cudaFree`, :py:obj:`~.cudaFreeArray`, :py:obj:`~.cudaMallocHost (C API)`, :py:obj:`~.cudaFreeHost`, :py:obj:`~.cudaHostAlloc`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.cuMipmappedArrayGetLevel`
     """
-    cdef ccudart.cudaMipmappedArray_const_t cmipmappedArray
+    cdef cyruntime.cudaMipmappedArray_const_t cymipmappedArray
     if mipmappedArray is None:
-        cmipmappedArray = <ccudart.cudaMipmappedArray_const_t><void_ptr>0
-    elif isinstance(mipmappedArray, (cudaMipmappedArray_const_t)):
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_const_t><void_ptr>0
+    elif isinstance(mipmappedArray, (cudaMipmappedArray_const_t,)):
         pmipmappedArray = int(mipmappedArray)
-        cmipmappedArray = <ccudart.cudaMipmappedArray_const_t><void_ptr>pmipmappedArray
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_const_t><void_ptr>pmipmappedArray
     else:
         pmipmappedArray = int(cudaMipmappedArray_const_t(mipmappedArray))
-        cmipmappedArray = <ccudart.cudaMipmappedArray_const_t><void_ptr>pmipmappedArray
-
+        cymipmappedArray = <cyruntime.cudaMipmappedArray_const_t><void_ptr>pmipmappedArray
     cdef cudaArray_t levelArray = cudaArray_t()
-    err = ccudart.cudaGetMipmappedArrayLevel(levelArray._ptr, cmipmappedArray, level)
+    err = cyruntime.cudaGetMipmappedArrayLevel(<cyruntime.cudaArray_t*>levelArray._ptr, cymipmappedArray, level)
     return (cudaError_t(err), levelArray)
 {{endif}}
 
@@ -16781,9 +16651,10 @@ def cudaMemcpy3D(p : Optional[cudaMemcpy3DParms]):
     --------
     :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemcpy3DAsync`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.make_cudaPos`, :py:obj:`~.cuMemcpy3D`
     """
-    cdef ccudart.cudaMemcpy3DParms* cp_ptr = p._ptr if p != None else NULL
+    cdef cyruntime.cudaMemcpy3DParms* cyp_ptr = p._ptr if p != None else NULL
     with nogil:
-        err = ccudart.cudaMemcpy3D(cp_ptr)
+        err = cyruntime.cudaMemcpy3D(cyp_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16818,8 +16689,8 @@ def cudaMemcpy3DPeer(p : Optional[cudaMemcpy3DPeerParms]):
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyPeer`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyPeerAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cuMemcpy3DPeer`
     """
-    cdef ccudart.cudaMemcpy3DPeerParms* cp_ptr = p._ptr if p != None else NULL
-    err = ccudart.cudaMemcpy3DPeer(cp_ptr)
+    cdef cyruntime.cudaMemcpy3DPeerParms* cyp_ptr = p._ptr if p != None else NULL
+    err = cyruntime.cudaMemcpy3DPeer(cyp_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16914,19 +16785,19 @@ def cudaMemcpy3DAsync(p : Optional[cudaMemcpy3DParms], stream):
     --------
     :py:obj:`~.cudaMalloc3D`, :py:obj:`~.cudaMalloc3DArray`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, ::::py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.make_cudaExtent`, :py:obj:`~.make_cudaPos`, :py:obj:`~.cuMemcpy3DAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaMemcpy3DParms* cp_ptr = p._ptr if p != None else NULL
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaMemcpy3DParms* cyp_ptr = p._ptr if p != None else NULL
     with nogil:
-        err = ccudart.cudaMemcpy3DAsync(cp_ptr, cstream)
+        err = cyruntime.cudaMemcpy3DAsync(cyp_ptr, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -16956,18 +16827,17 @@ def cudaMemcpy3DPeerAsync(p : Optional[cudaMemcpy3DPeerParms], stream):
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyPeer`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyPeerAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cuMemcpy3DPeerAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaMemcpy3DPeerParms* cp_ptr = p._ptr if p != None else NULL
-    err = ccudart.cudaMemcpy3DPeerAsync(cp_ptr, cstream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaMemcpy3DPeerParms* cyp_ptr = p._ptr if p != None else NULL
+    err = cyruntime.cudaMemcpy3DPeerAsync(cyp_ptr, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17009,7 +16879,7 @@ def cudaMemGetInfo():
     """
     cdef size_t free = 0
     cdef size_t total = 0
-    err = ccudart.cudaMemGetInfo(&free, &total)
+    err = cyruntime.cudaMemGetInfo(&free, &total)
     return (cudaError_t(err), free, total)
 {{endif}}
 
@@ -17044,20 +16914,19 @@ def cudaArrayGetInfo(array):
     --------
     :py:obj:`~.cuArrayGetDescriptor`, :py:obj:`~.cuArray3DGetDescriptor`
     """
-    cdef ccudart.cudaArray_t carray
+    cdef cyruntime.cudaArray_t cyarray
     if array is None:
-        carray = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(array, (cudaArray_t)):
+        cyarray = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(array, (cudaArray_t,)):
         parray = int(array)
-        carray = <ccudart.cudaArray_t><void_ptr>parray
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     else:
         parray = int(cudaArray_t(array))
-        carray = <ccudart.cudaArray_t><void_ptr>parray
-
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     cdef cudaChannelFormatDesc desc = cudaChannelFormatDesc()
     cdef cudaExtent extent = cudaExtent()
     cdef unsigned int flags = 0
-    err = ccudart.cudaArrayGetInfo(desc._ptr, extent._ptr, &flags, carray)
+    err = cyruntime.cudaArrayGetInfo(<cyruntime.cudaChannelFormatDesc*>desc._ptr, <cyruntime.cudaExtent*>extent._ptr, &flags, cyarray)
     return (cudaError_t(err), desc, extent, flags)
 {{endif}}
 
@@ -17101,18 +16970,17 @@ def cudaArrayGetPlane(hArray, unsigned int planeIdx):
     --------
     :py:obj:`~.cuArrayGetPlane`
     """
-    cdef ccudart.cudaArray_t chArray
+    cdef cyruntime.cudaArray_t cyhArray
     if hArray is None:
-        chArray = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(hArray, (cudaArray_t)):
+        cyhArray = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(hArray, (cudaArray_t,)):
         phArray = int(hArray)
-        chArray = <ccudart.cudaArray_t><void_ptr>phArray
+        cyhArray = <cyruntime.cudaArray_t><void_ptr>phArray
     else:
         phArray = int(cudaArray_t(hArray))
-        chArray = <ccudart.cudaArray_t><void_ptr>phArray
-
+        cyhArray = <cyruntime.cudaArray_t><void_ptr>phArray
     cdef cudaArray_t pPlaneArray = cudaArray_t()
-    err = ccudart.cudaArrayGetPlane(pPlaneArray._ptr, chArray, planeIdx)
+    err = cyruntime.cudaArrayGetPlane(<cyruntime.cudaArray_t*>pPlaneArray._ptr, cyhArray, planeIdx)
     return (cudaError_t(err), pPlaneArray)
 {{endif}}
 
@@ -17150,18 +17018,17 @@ def cudaArrayGetMemoryRequirements(array, int device):
     --------
     :py:obj:`~.cudaMipmappedArrayGetMemoryRequirements`
     """
-    cdef ccudart.cudaArray_t carray
+    cdef cyruntime.cudaArray_t cyarray
     if array is None:
-        carray = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(array, (cudaArray_t)):
+        cyarray = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(array, (cudaArray_t,)):
         parray = int(array)
-        carray = <ccudart.cudaArray_t><void_ptr>parray
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     else:
         parray = int(cudaArray_t(array))
-        carray = <ccudart.cudaArray_t><void_ptr>parray
-
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     cdef cudaArrayMemoryRequirements memoryRequirements = cudaArrayMemoryRequirements()
-    err = ccudart.cudaArrayGetMemoryRequirements(memoryRequirements._ptr, carray, device)
+    err = cyruntime.cudaArrayGetMemoryRequirements(<cyruntime.cudaArrayMemoryRequirements*>memoryRequirements._ptr, cyarray, device)
     return (cudaError_t(err), memoryRequirements)
 {{endif}}
 
@@ -17199,18 +17066,17 @@ def cudaMipmappedArrayGetMemoryRequirements(mipmap, int device):
     --------
     :py:obj:`~.cudaArrayGetMemoryRequirements`
     """
-    cdef ccudart.cudaMipmappedArray_t cmipmap
+    cdef cyruntime.cudaMipmappedArray_t cymipmap
     if mipmap is None:
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>0
-    elif isinstance(mipmap, (cudaMipmappedArray_t)):
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>0
+    elif isinstance(mipmap, (cudaMipmappedArray_t,)):
         pmipmap = int(mipmap)
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     else:
         pmipmap = int(cudaMipmappedArray_t(mipmap))
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
-
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     cdef cudaArrayMemoryRequirements memoryRequirements = cudaArrayMemoryRequirements()
-    err = ccudart.cudaMipmappedArrayGetMemoryRequirements(memoryRequirements._ptr, cmipmap, device)
+    err = cyruntime.cudaMipmappedArrayGetMemoryRequirements(<cyruntime.cudaArrayMemoryRequirements*>memoryRequirements._ptr, cymipmap, device)
     return (cudaError_t(err), memoryRequirements)
 {{endif}}
 
@@ -17254,18 +17120,17 @@ def cudaArrayGetSparseProperties(array):
     --------
     :py:obj:`~.cudaMipmappedArrayGetSparseProperties`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccudart.cudaArray_t carray
+    cdef cyruntime.cudaArray_t cyarray
     if array is None:
-        carray = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(array, (cudaArray_t)):
+        cyarray = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(array, (cudaArray_t,)):
         parray = int(array)
-        carray = <ccudart.cudaArray_t><void_ptr>parray
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     else:
         parray = int(cudaArray_t(array))
-        carray = <ccudart.cudaArray_t><void_ptr>parray
-
+        cyarray = <cyruntime.cudaArray_t><void_ptr>parray
     cdef cudaArraySparseProperties sparseProperties = cudaArraySparseProperties()
-    err = ccudart.cudaArrayGetSparseProperties(sparseProperties._ptr, carray)
+    err = cyruntime.cudaArrayGetSparseProperties(<cyruntime.cudaArraySparseProperties*>sparseProperties._ptr, cyarray)
     return (cudaError_t(err), sparseProperties)
 {{endif}}
 
@@ -17309,18 +17174,17 @@ def cudaMipmappedArrayGetSparseProperties(mipmap):
     --------
     :py:obj:`~.cudaArrayGetSparseProperties`, :py:obj:`~.cuMemMapArrayAsync`
     """
-    cdef ccudart.cudaMipmappedArray_t cmipmap
+    cdef cyruntime.cudaMipmappedArray_t cymipmap
     if mipmap is None:
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>0
-    elif isinstance(mipmap, (cudaMipmappedArray_t)):
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>0
+    elif isinstance(mipmap, (cudaMipmappedArray_t,)):
         pmipmap = int(mipmap)
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     else:
         pmipmap = int(cudaMipmappedArray_t(mipmap))
-        cmipmap = <ccudart.cudaMipmappedArray_t><void_ptr>pmipmap
-
+        cymipmap = <cyruntime.cudaMipmappedArray_t><void_ptr>pmipmap
     cdef cudaArraySparseProperties sparseProperties = cudaArraySparseProperties()
-    err = ccudart.cudaMipmappedArrayGetSparseProperties(sparseProperties._ptr, cmipmap)
+    err = cyruntime.cudaMipmappedArrayGetSparseProperties(<cyruntime.cudaArraySparseProperties*>sparseProperties._ptr, cymipmap)
     return (cudaError_t(err), sparseProperties)
 {{endif}}
 
@@ -17364,13 +17228,14 @@ def cudaMemcpy(dst, src, size_t count, kind not None : cudaMemcpyKind):
     --------
     :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyDtoH`, :py:obj:`~.cuMemcpyHtoD`, :py:obj:`~.cuMemcpyDtoD`, :py:obj:`~.cuMemcpy`
     """
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy(cdst_ptr, csrc_ptr, count, ckind)
+        err = cyruntime.cudaMemcpy(cydst_ptr, cysrc_ptr, count, cykind)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17413,12 +17278,13 @@ def cudaMemcpyPeer(dst, int dstDevice, src, int srcDevice, size_t count):
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpyPeerAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cuMemcpyPeer`
     """
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     with nogil:
-        err = ccudart.cudaMemcpyPeer(cdst_ptr, dstDevice, csrc_ptr, srcDevice, count)
+        err = cyruntime.cudaMemcpyPeer(cydst_ptr, dstDevice, cysrc_ptr, srcDevice, count)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17472,13 +17338,14 @@ def cudaMemcpy2D(dst, size_t dpitch, src, size_t spitch, size_t width, size_t he
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DUnaligned`
     """
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2D(cdst_ptr, dpitch, csrc_ptr, spitch, width, height, ckind)
+        err = cyruntime.cudaMemcpy2D(cydst_ptr, dpitch, cysrc_ptr, spitch, width, height, cykind)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17533,21 +17400,21 @@ def cudaMemcpy2DToArray(dst, size_t wOffset, size_t hOffset, src, size_t spitch,
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DUnaligned`
     """
-    cdef ccudart.cudaArray_t cdst
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2DToArray(cdst, wOffset, hOffset, csrc_ptr, spitch, width, height, ckind)
+        err = cyruntime.cudaMemcpy2DToArray(cydst, wOffset, hOffset, cysrc_ptr, spitch, width, height, cykind)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17602,21 +17469,21 @@ def cudaMemcpy2DFromArray(dst, size_t dpitch, src, size_t wOffset, size_t hOffse
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DUnaligned`
     """
-    cdef ccudart.cudaArray_const_t csrc
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2DFromArray(cdst_ptr, dpitch, csrc, wOffset, hOffset, width, height, ckind)
+        err = cyruntime.cudaMemcpy2DFromArray(cydst_ptr, dpitch, cysrc, wOffset, hOffset, width, height, cykind)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17671,28 +17538,26 @@ def cudaMemcpy2DArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, siz
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpy2D`, :py:obj:`~.cuMemcpy2DUnaligned`
     """
-    cdef ccudart.cudaArray_const_t csrc
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdef ccudart.cudaArray_t cdst
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpy2DArrayToArray(cdst, wOffsetDst, hOffsetDst, csrc, wOffsetSrc, hOffsetSrc, width, height, ckind)
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpy2DArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, width, height, cykind)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17748,23 +17613,23 @@ def cudaMemcpyAsync(dst, src, size_t count, kind not None : cudaMemcpyKind, stre
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyAsync`, :py:obj:`~.cuMemcpyDtoHAsync`, :py:obj:`~.cuMemcpyHtoDAsync`, :py:obj:`~.cuMemcpyDtoDAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpyAsync(cdst_ptr, csrc_ptr, count, ckind, cstream)
+        err = cyruntime.cudaMemcpyAsync(cydst_ptr, cysrc_ptr, count, cykind, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17807,22 +17672,22 @@ def cudaMemcpyPeerAsync(dst, int dstDevice, src, int srcDevice, size_t count, st
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyPeer`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cuMemcpyPeerAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
     with nogil:
-        err = ccudart.cudaMemcpyPeerAsync(cdst_ptr, dstDevice, csrc_ptr, srcDevice, count, cstream)
+        err = cyruntime.cudaMemcpyPeerAsync(cydst_ptr, dstDevice, cysrc_ptr, srcDevice, count, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17889,23 +17754,23 @@ def cudaMemcpy2DAsync(dst, size_t dpitch, src, size_t spitch, size_t width, size
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpy2DAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2DAsync(cdst_ptr, dpitch, csrc_ptr, spitch, width, height, ckind, cstream)
+        err = cyruntime.cudaMemcpy2DAsync(cydst_ptr, dpitch, cysrc_ptr, spitch, width, height, cykind, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -17973,31 +17838,30 @@ def cudaMemcpy2DToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t sp
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`,
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaArray_t cdst
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2DToArrayAsync(cdst, wOffset, hOffset, csrc_ptr, spitch, width, height, ckind, cstream)
+        err = cyruntime.cudaMemcpy2DToArrayAsync(cydst, wOffset, hOffset, cysrc_ptr, spitch, width, height, cykind, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18064,31 +17928,30 @@ def cudaMemcpy2DFromArrayAsync(dst, size_t dpitch, src, size_t wOffset, size_t h
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`,
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaArray_const_t csrc
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
     with nogil:
-        err = ccudart.cudaMemcpy2DFromArrayAsync(cdst_ptr, dpitch, csrc, wOffset, hOffset, width, height, ckind, cstream)
+        err = cyruntime.cudaMemcpy2DFromArrayAsync(cydst_ptr, dpitch, cysrc, wOffset, hOffset, width, height, cykind, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18122,10 +17985,11 @@ def cudaMemset(devPtr, int value, size_t count):
     --------
     :py:obj:`~.cuMemsetD8`, :py:obj:`~.cuMemsetD16`, :py:obj:`~.cuMemsetD32`
     """
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     with nogil:
-        err = ccudart.cudaMemset(cdevPtr_ptr, value, count)
+        err = cyruntime.cudaMemset(cydevPtr_ptr, value, count)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18166,9 +18030,9 @@ def cudaMemset2D(devPtr, size_t pitch, int value, size_t width, size_t height):
     --------
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemsetAsync`, :py:obj:`~.cudaMemset2DAsync`, :py:obj:`~.cudaMemset3DAsync`, :py:obj:`~.cuMemsetD2D8`, :py:obj:`~.cuMemsetD2D16`, :py:obj:`~.cuMemsetD2D32`
     """
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaMemset2D(cdevPtr_ptr, pitch, value, width, height)
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaMemset2D(cydevPtr_ptr, pitch, value, width, height)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18221,7 +18085,7 @@ def cudaMemset3D(pitchedDevPtr not None : cudaPitchedPtr, int value, extent not
     --------
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaMemsetAsync`, :py:obj:`~.cudaMemset2DAsync`, :py:obj:`~.cudaMemset3DAsync`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.make_cudaPitchedPtr`, :py:obj:`~.make_cudaExtent`
     """
-    err = ccudart.cudaMemset3D(pitchedDevPtr._ptr[0], value, extent._ptr[0])
+    err = cyruntime.cudaMemset3D(pitchedDevPtr._ptr[0], value, extent._ptr[0])
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18263,20 +18127,20 @@ def cudaMemsetAsync(devPtr, int value, size_t count, stream):
     --------
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemset2DAsync`, :py:obj:`~.cudaMemset3DAsync`, :py:obj:`~.cuMemsetD8Async`, :py:obj:`~.cuMemsetD16Async`, :py:obj:`~.cuMemsetD32Async`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     with nogil:
-        err = ccudart.cudaMemsetAsync(cdevPtr_ptr, value, count, cstream)
+        err = cyruntime.cudaMemsetAsync(cydevPtr_ptr, value, count, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18325,19 +18189,18 @@ def cudaMemset2DAsync(devPtr, size_t pitch, int value, size_t width, size_t heig
     --------
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemsetAsync`, :py:obj:`~.cudaMemset3DAsync`, :py:obj:`~.cuMemsetD2D8Async`, :py:obj:`~.cuMemsetD2D16Async`, :py:obj:`~.cuMemsetD2D32Async`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaMemset2DAsync(cdevPtr_ptr, pitch, value, width, height, cstream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaMemset2DAsync(cydevPtr_ptr, pitch, value, width, height, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18398,17 +18261,16 @@ def cudaMemset3DAsync(pitchedDevPtr not None : cudaPitchedPtr, int value, extent
     --------
     :py:obj:`~.cudaMemset`, :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaMemset3D`, :py:obj:`~.cudaMemsetAsync`, :py:obj:`~.cudaMemset2DAsync`, :py:obj:`~.cudaMalloc3D`, :py:obj:`~.make_cudaPitchedPtr`, :py:obj:`~.make_cudaExtent`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    err = ccudart.cudaMemset3DAsync(pitchedDevPtr._ptr[0], value, extent._ptr[0], cstream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    err = cyruntime.cudaMemset3DAsync(pitchedDevPtr._ptr[0], value, extent._ptr[0], cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18494,20 +18356,20 @@ def cudaMemPrefetchAsync(devPtr, size_t count, int dstDevice, stream):
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyPeer`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cudaMemAdvise`, :py:obj:`~.cuMemPrefetchAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     with nogil:
-        err = ccudart.cudaMemPrefetchAsync(cdevPtr_ptr, count, dstDevice, cstream)
+        err = cyruntime.cudaMemPrefetchAsync(cydevPtr_ptr, count, dstDevice, cystream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18673,11 +18535,12 @@ def cudaMemAdvise(devPtr, size_t count, advice not None : cudaMemoryAdvise, int
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpyPeer`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy3DPeerAsync`, :py:obj:`~.cudaMemPrefetchAsync`, :py:obj:`~.cuMemAdvise`
     """
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    cdef ccudart.cudaMemoryAdvise cadvice = advice.value
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    cdef cyruntime.cudaMemoryAdvise cyadvice = advice.value
     with nogil:
-        err = ccudart.cudaMemAdvise(cdevPtr_ptr, count, cadvice, device)
+        err = cyruntime.cudaMemAdvise(cydevPtr_ptr, count, cyadvice, device)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18764,19 +18627,19 @@ def cudaMemRangeGetAttribute(size_t dataSize, attribute not None : cudaMemRangeA
     --------
     :py:obj:`~.cudaMemRangeGetAttributes`, :py:obj:`~.cudaMemPrefetchAsync`, :py:obj:`~.cudaMemAdvise`, :py:obj:`~.cuMemRangeGetAttribute`
     """
-    cdef utils.HelperCUmem_range_attribute cdata = utils.HelperCUmem_range_attribute(attribute, dataSize)
-    cdef void* cdata_ptr = <void*><void_ptr>cdata.cptr
-    cdef ccudart.cudaMemRangeAttribute cattribute = attribute.value
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaMemRangeGetAttribute(cdata_ptr, dataSize, cattribute, cdevPtr_ptr, count)
-    return (cudaError_t(err), cdata.pyObj())
+    cdef utils.HelperCUmem_range_attribute cydata = utils.HelperCUmem_range_attribute(attribute, dataSize)
+    cdef void* cydata_ptr = <void*><void_ptr>cydata.cptr
+    cdef cyruntime.cudaMemRangeAttribute cyattribute = attribute.value
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaMemRangeGetAttribute(cydata_ptr, dataSize, cyattribute, cydevPtr_ptr, count)
+    return (cudaError_t(err), cydata.pyObj())
 {{endif}}
 
 {{if 'cudaMemRangeGetAttributes' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaMemRangeGetAttributes(dataSizes : List[int], attributes : Optional[List[cudaMemRangeAttribute]], size_t numAttributes, devPtr, size_t count):
+def cudaMemRangeGetAttributes(dataSizes : Tuple[int] | List[int], attributes : Optional[Tuple[cudaMemRangeAttribute] | List[cudaMemRangeAttribute]], size_t numAttributes, devPtr, size_t count):
     """ Query attributes of a given memory range.
 
     Query attributes of the memory range starting at `devPtr` with a size
@@ -18827,21 +18690,19 @@ def cudaMemRangeGetAttributes(dataSizes : List[int], attributes : Optional[List[
     """
     attributes = [] if attributes is None else attributes
     if not all(isinstance(_x, (cudaMemRangeAttribute)) for _x in attributes):
-        raise TypeError("Argument 'attributes' is not instance of type (expected List[ccudart.cudaMemRangeAttribute]")
-
+        raise TypeError("Argument 'attributes' is not instance of type (expected Tuple[cyruntime.cudaMemRangeAttribute] or List[cyruntime.cudaMemRangeAttribute]")
     if not all(isinstance(_x, (int)) for _x in dataSizes):
-        raise TypeError("Argument 'dataSizes' is not instance of type (expected List[int]")
-
+        raise TypeError("Argument 'dataSizes' is not instance of type (expected Tuple[int] or List[int]")
     pylist = [utils.HelperCUmem_range_attribute(pyattributes, pydataSizes) for (pyattributes, pydataSizes) in zip(attributes, dataSizes)]
-    cdef utils.InputVoidPtrPtrHelper voidStarHelper = utils.InputVoidPtrPtrHelper(pylist)
-    cdef void** cvoidStarHelper_ptr = <void**><void_ptr>voidStarHelper.cptr
-    cdef vector[size_t] cdataSizes = dataSizes
-    cdef vector[ccudart.cudaMemRangeAttribute] cattributes = [pyattributes.value for pyattributes in (attributes)]
+    cdef utils.InputVoidPtrPtrHelper voidStarHelperdata = utils.InputVoidPtrPtrHelper(pylist)
+    cdef void** cyvoidStarHelper_ptr = <void**><void_ptr>voidStarHelperdata.cptr
+    cdef vector[size_t] cydataSizes = dataSizes
+    cdef vector[cyruntime.cudaMemRangeAttribute] cyattributes = [pyattributes.value for pyattributes in (attributes)]
     if numAttributes > <size_t>len(dataSizes): raise RuntimeError("List is too small: " + str(len(dataSizes)) + " < " + str(numAttributes))
     if numAttributes > <size_t>len(attributes): raise RuntimeError("List is too small: " + str(len(attributes)) + " < " + str(numAttributes))
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
-    err = ccudart.cudaMemRangeGetAttributes(cvoidStarHelper_ptr, cdataSizes.data(), cattributes.data(), numAttributes, cdevPtr_ptr, count)
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
+    err = cyruntime.cudaMemRangeGetAttributes(cyvoidStarHelper_ptr, cydataSizes.data(), cyattributes.data(), numAttributes, cydevPtr_ptr, count)
     return (cudaError_t(err), [obj.pyObj() for obj in pylist])
 {{endif}}
 
@@ -18888,20 +18749,19 @@ def cudaMemcpyToArray(dst, size_t wOffset, size_t hOffset, src, size_t count, ki
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpyFromArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpyArrayToArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpyToArrayAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpyFromArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyHtoA`, :py:obj:`~.cuMemcpyDtoA`
     """
-    cdef ccudart.cudaArray_t cdst
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpyToArray(cdst, wOffset, hOffset, csrc_ptr, count, ckind)
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpyToArray(cydst, wOffset, hOffset, cysrc_ptr, count, cykind)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -18948,20 +18808,19 @@ def cudaMemcpyFromArray(dst, src, size_t wOffset, size_t hOffset, size_t count,
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpyToArray`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpyArrayToArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpyToArrayAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpyFromArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyAtoH`, :py:obj:`~.cuMemcpyAtoD`
     """
-    cdef ccudart.cudaArray_const_t csrc
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpyFromArray(cdst_ptr, csrc, wOffset, hOffset, count, ckind)
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpyFromArray(cydst_ptr, cysrc, wOffset, hOffset, count, cykind)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19013,28 +18872,26 @@ def cudaMemcpyArrayToArray(dst, size_t wOffsetDst, size_t hOffsetDst, src, size_
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpyToArray`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpyFromArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpyToArrayAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpyFromArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyAtoA`
     """
-    cdef ccudart.cudaArray_const_t csrc
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdef ccudart.cudaArray_t cdst
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpyArrayToArray(cdst, wOffsetDst, hOffsetDst, csrc, wOffsetSrc, hOffsetSrc, count, ckind)
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpyArrayToArray(cydst, wOffsetDst, hOffsetDst, cysrc, wOffsetSrc, hOffsetSrc, count, cykind)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19090,30 +18947,28 @@ def cudaMemcpyToArrayAsync(dst, size_t wOffset, size_t hOffset, src, size_t coun
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpyToArray`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpyFromArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpyArrayToArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpyFromArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyHtoAAsync`, :py:obj:`~.cuMemcpy2DAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaArray_t cdst
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaArray_t cydst
     if dst is None:
-        cdst = <ccudart.cudaArray_t><void_ptr>0
-    elif isinstance(dst, (cudaArray_t)):
+        cydst = <cyruntime.cudaArray_t><void_ptr>0
+    elif isinstance(dst, (cudaArray_t,)):
         pdst = int(dst)
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
     else:
         pdst = int(cudaArray_t(dst))
-        cdst = <ccudart.cudaArray_t><void_ptr>pdst
-
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpyToArrayAsync(cdst, wOffset, hOffset, csrc_ptr, count, ckind, cstream)
+        cydst = <cyruntime.cudaArray_t><void_ptr>pdst
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpyToArrayAsync(cydst, wOffset, hOffset, cysrc_ptr, count, cykind, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19169,30 +19024,28 @@ def cudaMemcpyFromArrayAsync(dst, src, size_t wOffset, size_t hOffset, size_t co
     --------
     :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaMemcpy2D`, :py:obj:`~.cudaMemcpyToArray`, :py:obj:`~.cudaMemcpy2DToArray`, :py:obj:`~.cudaMemcpyFromArray`, :py:obj:`~.cudaMemcpy2DFromArray`, :py:obj:`~.cudaMemcpyArrayToArray`, :py:obj:`~.cudaMemcpy2DArrayToArray`, :py:obj:`~.cudaMemcpyToSymbol`, :py:obj:`~.cudaMemcpyFromSymbol`, :py:obj:`~.cudaMemcpyAsync`, :py:obj:`~.cudaMemcpy2DAsync`, :py:obj:`~.cudaMemcpyToArrayAsync`, :py:obj:`~.cudaMemcpy2DToArrayAsync`, :py:obj:`~.cudaMemcpy2DFromArrayAsync`, :py:obj:`~.cudaMemcpyToSymbolAsync`, :py:obj:`~.cudaMemcpyFromSymbolAsync`, :py:obj:`~.cuMemcpyAtoHAsync`, :py:obj:`~.cuMemcpy2DAsync`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaArray_const_t csrc
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaArray_const_t cysrc
     if src is None:
-        csrc = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(src, (cudaArray_const_t)):
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(src, (cudaArray_const_t,)):
         psrc = int(src)
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
     else:
         psrc = int(cudaArray_const_t(src))
-        csrc = <ccudart.cudaArray_const_t><void_ptr>psrc
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaMemcpyFromArrayAsync(cdst_ptr, csrc, wOffset, hOffset, count, ckind, cstream)
+        cysrc = <cyruntime.cudaArray_const_t><void_ptr>psrc
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaMemcpyFromArrayAsync(cydst_ptr, cysrc, wOffset, hOffset, count, cykind, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19235,19 +19088,19 @@ def cudaMallocAsync(size_t size, hStream):
 
     During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     cdef void_ptr devPtr = 0
     with nogil:
-        err = ccudart.cudaMallocAsync(<void**>&devPtr, size, chStream)
+        err = cyruntime.cudaMallocAsync(<void**>&devPtr, size, cyhStream)
+
     return (cudaError_t(err), devPtr)
 {{endif}}
 
@@ -19282,20 +19135,20 @@ def cudaFreeAsync(devPtr, hStream):
     -----
     During stream capture, this function results in the creation of a free node and must therefore be passed the address of a graph allocation.
     """
-    cdef ccudart.cudaStream_t chStream
+    cdef cyruntime.cudaStream_t cyhStream
     if hStream is None:
-        chStream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(hStream, (cudaStream_t,cuda.CUstream)):
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(hStream, (cudaStream_t,driver.CUstream)):
         phStream = int(hStream)
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
     else:
         phStream = int(cudaStream_t(hStream))
-        chStream = <ccudart.cudaStream_t><void_ptr>phStream
-
-    cdevPtr = utils.HelperInputVoidPtr(devPtr)
-    cdef void* cdevPtr_ptr = <void*><void_ptr>cdevPtr.cptr
+        cyhStream = <cyruntime.cudaStream_t><void_ptr>phStream
+    cydevPtr = utils.HelperInputVoidPtr(devPtr)
+    cdef void* cydevPtr_ptr = <void*><void_ptr>cydevPtr.cptr
     with nogil:
-        err = ccudart.cudaFreeAsync(cdevPtr_ptr, chStream)
+        err = cyruntime.cudaFreeAsync(cydevPtr_ptr, cyhStream)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19336,18 +19189,18 @@ def cudaMemPoolTrimTo(memPool, size_t minBytesToKeep):
 
     : Allocations that have been asynchronously freed but whose completion has not been observed on the host (eg. by a synchronize) can count as outstanding.
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     with nogil:
-        err = ccudart.cudaMemPoolTrimTo(cmemPool, minBytesToKeep)
+        err = cyruntime.cudaMemPoolTrimTo(cymemPool, minBytesToKeep)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19411,21 +19264,21 @@ def cudaMemPoolSetAttribute(memPool, attr not None : cudaMemPoolAttr, value):
     --------
     :py:obj:`~.cuMemPoolSetAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaDeviceGetDefaultMemPool`, :py:obj:`~.cudaDeviceGetMemPool`, :py:obj:`~.cudaMemPoolCreate`
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    cdef ccudart.cudaMemPoolAttr cattr = attr.value
-    cdef utils.HelperCUmemPool_attribute cvalue = utils.HelperCUmemPool_attribute(attr, value, is_getter=False)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    cdef cyruntime.cudaMemPoolAttr cyattr = attr.value
+    cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, value, is_getter=False)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     with nogil:
-        err = ccudart.cudaMemPoolSetAttribute(cmemPool, cattr, cvalue_ptr)
+        err = cyruntime.cudaMemPoolSetAttribute(cymemPool, cyattr, cyvalue_ptr)
+
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19495,28 +19348,28 @@ def cudaMemPoolGetAttribute(memPool, attr not None : cudaMemPoolAttr):
     --------
     :py:obj:`~.cuMemPoolGetAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaDeviceGetDefaultMemPool`, :py:obj:`~.cudaDeviceGetMemPool`, :py:obj:`~.cudaMemPoolCreate`
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    cdef ccudart.cudaMemPoolAttr cattr = attr.value
-    cdef utils.HelperCUmemPool_attribute cvalue = utils.HelperCUmemPool_attribute(attr, 0, is_getter=True)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    cdef cyruntime.cudaMemPoolAttr cyattr = attr.value
+    cdef utils.HelperCUmemPool_attribute cyvalue = utils.HelperCUmemPool_attribute(attr, 0, is_getter=True)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
     with nogil:
-        err = ccudart.cudaMemPoolGetAttribute(cmemPool, cattr, cvalue_ptr)
-    return (cudaError_t(err), cvalue.pyObj())
+        err = cyruntime.cudaMemPoolGetAttribute(cymemPool, cyattr, cyvalue_ptr)
+
+    return (cudaError_t(err), cyvalue.pyObj())
 {{endif}}
 
 {{if 'cudaMemPoolSetAccess' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaMemPoolSetAccess(memPool, descList : Optional[List[cudaMemAccessDesc]], size_t count):
+def cudaMemPoolSetAccess(memPool, descList : Optional[Tuple[cudaMemAccessDesc] | List[cudaMemAccessDesc]], size_t count):
     """ Controls visibility of pools between devices.
 
     Parameters
@@ -19539,31 +19392,28 @@ def cudaMemPoolSetAccess(memPool, descList : Optional[List[cudaMemAccessDesc]],
     :py:obj:`~.cuMemPoolSetAccess`, :py:obj:`~.cudaMemPoolGetAccess`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`
     """
     descList = [] if descList is None else descList
-    if not all(isinstance(_x, (cudaMemAccessDesc)) for _x in descList):
-        raise TypeError("Argument 'descList' is not instance of type (expected List[ccudart.cudaMemAccessDesc]")
-
-    cdef ccudart.cudaMemPool_t cmemPool
+    if not all(isinstance(_x, (cudaMemAccessDesc,)) for _x in descList):
+        raise TypeError("Argument 'descList' is not instance of type (expected Tuple[cyruntime.cudaMemAccessDesc,] or List[cyruntime.cudaMemAccessDesc,]")
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    cdef ccudart.cudaMemAccessDesc* cdescList = NULL
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    cdef cyruntime.cudaMemAccessDesc* cydescList = NULL
     if len(descList) > 0:
-        cdescList = <ccudart.cudaMemAccessDesc*> calloc(len(descList), sizeof(ccudart.cudaMemAccessDesc))
-        if cdescList is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(descList)) + 'x' + str(sizeof(ccudart.cudaMemAccessDesc)))
+        cydescList = <cyruntime.cudaMemAccessDesc*> calloc(len(descList), sizeof(cyruntime.cudaMemAccessDesc))
+        if cydescList is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(descList)) + 'x' + str(sizeof(cyruntime.cudaMemAccessDesc)))
         for idx in range(len(descList)):
-            memcpy(&cdescList[idx], (<cudaMemAccessDesc>descList[idx])._ptr, sizeof(ccudart.cudaMemAccessDesc))
-
+            string.memcpy(&cydescList[idx], (<cudaMemAccessDesc>descList[idx])._ptr, sizeof(cyruntime.cudaMemAccessDesc))
     if count > <size_t>len(descList): raise RuntimeError("List is too small: " + str(len(descList)) + " < " + str(count))
-    err = ccudart.cudaMemPoolSetAccess(cmemPool, (<cudaMemAccessDesc>descList[0])._ptr if len(descList) == 1 else cdescList, count)
-    if cdescList is not NULL:
-        free(cdescList)
+    err = cyruntime.cudaMemPoolSetAccess(cymemPool, (<cudaMemAccessDesc>descList[0])._ptr if len(descList) == 1 else cydescList, count)
+    if cydescList is not NULL:
+        free(cydescList)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19594,19 +19444,18 @@ def cudaMemPoolGetAccess(memPool, location : Optional[cudaMemLocation]):
     --------
     :py:obj:`~.cuMemPoolGetAccess`, :py:obj:`~.cudaMemPoolSetAccess`
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    cdef ccudart.cudaMemAccessFlags flags
-    cdef ccudart.cudaMemLocation* clocation_ptr = location._ptr if location != None else NULL
-    err = ccudart.cudaMemPoolGetAccess(&flags, cmemPool, clocation_ptr)
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    cdef cyruntime.cudaMemAccessFlags flags
+    cdef cyruntime.cudaMemLocation* cylocation_ptr = location._ptr if location != None else NULL
+    err = cyruntime.cudaMemPoolGetAccess(&flags, cymemPool, cylocation_ptr)
     return (cudaError_t(err), cudaMemAccessFlags(flags))
 {{endif}}
 
@@ -19644,8 +19493,8 @@ def cudaMemPoolCreate(poolProps : Optional[cudaMemPoolProps]):
     Specifying cudaMemHandleTypeNone creates a memory pool that will not support IPC.
     """
     cdef cudaMemPool_t memPool = cudaMemPool_t()
-    cdef ccudart.cudaMemPoolProps* cpoolProps_ptr = poolProps._ptr if poolProps != None else NULL
-    err = ccudart.cudaMemPoolCreate(<ccudart.cudaMemPool_t*>memPool._ptr, cpoolProps_ptr)
+    cdef cyruntime.cudaMemPoolProps* cypoolProps_ptr = poolProps._ptr if poolProps != None else NULL
+    err = cyruntime.cudaMemPoolCreate(<cyruntime.cudaMemPool_t*>memPool._ptr, cypoolProps_ptr)
     return (cudaError_t(err), memPool)
 {{endif}}
 
@@ -19682,17 +19531,16 @@ def cudaMemPoolDestroy(memPool):
     -----
     A device's default memory pool cannot be destroyed.
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    err = ccudart.cudaMemPoolDestroy(cmemPool)
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    err = cyruntime.cudaMemPoolDestroy(cymemPool)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -19731,28 +19579,26 @@ def cudaMallocFromPoolAsync(size_t size, memPool, stream):
     -----
     During stream capture, this function results in the creation of an allocation node. In this case, the allocation is owned by the graph instead of the memory pool. The memory pool's properties are used to set the node's creation parameters.
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaMemPool_t cmemPool
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     cdef void_ptr ptr = 0
-    err = ccudart.cudaMallocFromPoolAsync(<void**>&ptr, size, cmemPool, cstream)
+    err = cyruntime.cudaMallocFromPoolAsync(<void**>&ptr, size, cymemPool, cystream)
     return (cudaError_t(err), ptr)
 {{endif}}
 
@@ -19795,21 +19641,20 @@ def cudaMemPoolExportToShareableHandle(memPool, handleType not None : cudaMemAll
     -----
     : To create an IPC capable mempool, create a mempool with a CUmemAllocationHandleType other than cudaMemHandleTypeNone.
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
-    cdef utils.HelperCUmemAllocationHandleType cshareableHandle = utils.HelperCUmemAllocationHandleType(handleType)
-    cdef void* cshareableHandle_ptr = <void*><void_ptr>cshareableHandle.cptr
-    cdef ccudart.cudaMemAllocationHandleType chandleType = handleType.value
-    err = ccudart.cudaMemPoolExportToShareableHandle(cshareableHandle_ptr, cmemPool, chandleType, flags)
-    return (cudaError_t(err), cshareableHandle.pyObj())
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
+    cdef utils.HelperCUmemAllocationHandleType cyshareableHandle = utils.HelperCUmemAllocationHandleType(handleType)
+    cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
+    cdef cyruntime.cudaMemAllocationHandleType cyhandleType = handleType.value
+    err = cyruntime.cudaMemPoolExportToShareableHandle(cyshareableHandle_ptr, cymemPool, cyhandleType, flags)
+    return (cudaError_t(err), cyshareableHandle.pyObj())
 {{endif}}
 
 {{if 'cudaMemPoolImportFromShareableHandle' in found_functions}}
@@ -19846,10 +19691,10 @@ def cudaMemPoolImportFromShareableHandle(shareableHandle, handleType not None :
     Imported memory pools do not support creating new allocations. As such imported memory pools may not be used in :py:obj:`~.cudaDeviceSetMemPool` or :py:obj:`~.cudaMallocFromPoolAsync` calls.
     """
     cdef cudaMemPool_t memPool = cudaMemPool_t()
-    cshareableHandle = utils.HelperInputVoidPtr(shareableHandle)
-    cdef void* cshareableHandle_ptr = <void*><void_ptr>cshareableHandle.cptr
-    cdef ccudart.cudaMemAllocationHandleType chandleType = handleType.value
-    err = ccudart.cudaMemPoolImportFromShareableHandle(<ccudart.cudaMemPool_t*>memPool._ptr, cshareableHandle_ptr, chandleType, flags)
+    cyshareableHandle = utils.HelperInputVoidPtr(shareableHandle)
+    cdef void* cyshareableHandle_ptr = <void*><void_ptr>cyshareableHandle.cptr
+    cdef cyruntime.cudaMemAllocationHandleType cyhandleType = handleType.value
+    err = cyruntime.cudaMemPoolImportFromShareableHandle(<cyruntime.cudaMemPool_t*>memPool._ptr, cyshareableHandle_ptr, cyhandleType, flags)
     return (cudaError_t(err), memPool)
 {{endif}}
 
@@ -19881,9 +19726,9 @@ def cudaMemPoolExportPointer(ptr):
     :py:obj:`~.cuMemPoolExportPointer`, :py:obj:`~.cudaMemPoolExportToShareableHandle`, :py:obj:`~.cudaMemPoolImportFromShareableHandle`, :py:obj:`~.cudaMemPoolImportPointer`
     """
     cdef cudaMemPoolPtrExportData exportData = cudaMemPoolPtrExportData()
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
-    err = ccudart.cudaMemPoolExportPointer(exportData._ptr, cptr_ptr)
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
+    err = cyruntime.cudaMemPoolExportPointer(<cyruntime.cudaMemPoolPtrExportData*>exportData._ptr, cyptr_ptr)
     return (cudaError_t(err), exportData)
 {{endif}}
 
@@ -19923,19 +19768,18 @@ def cudaMemPoolImportPointer(memPool, exportData : Optional[cudaMemPoolPtrExport
     -----
     The :py:obj:`~.cudaFreeAsync` api may be used in the exporting process before the :py:obj:`~.cudaFreeAsync` operation completes in its stream as long as the :py:obj:`~.cudaFreeAsync` in the exporting process specifies a stream with a stream dependency on the importing process's :py:obj:`~.cudaFreeAsync`.
     """
-    cdef ccudart.cudaMemPool_t cmemPool
+    cdef cyruntime.cudaMemPool_t cymemPool
     if memPool is None:
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>0
-    elif isinstance(memPool, (cudaMemPool_t,cuda.CUmemoryPool)):
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>0
+    elif isinstance(memPool, (cudaMemPool_t,driver.CUmemoryPool)):
         pmemPool = int(memPool)
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     else:
         pmemPool = int(cudaMemPool_t(memPool))
-        cmemPool = <ccudart.cudaMemPool_t><void_ptr>pmemPool
-
+        cymemPool = <cyruntime.cudaMemPool_t><void_ptr>pmemPool
     cdef void_ptr ptr = 0
-    cdef ccudart.cudaMemPoolPtrExportData* cexportData_ptr = exportData._ptr if exportData != None else NULL
-    err = ccudart.cudaMemPoolImportPointer(<void**>&ptr, cmemPool, cexportData_ptr)
+    cdef cyruntime.cudaMemPoolPtrExportData* cyexportData_ptr = exportData._ptr if exportData != None else NULL
+    err = cyruntime.cudaMemPoolImportPointer(<void**>&ptr, cymemPool, cyexportData_ptr)
     return (cudaError_t(err), ptr)
 {{endif}}
 
@@ -20002,9 +19846,9 @@ def cudaPointerGetAttributes(ptr):
     In CUDA 11.0 forward passing host pointer will return :py:obj:`~.cudaMemoryTypeUnregistered` in :py:obj:`~.cudaPointerAttributes.type` and call will return :py:obj:`~.cudaSuccess`.
     """
     cdef cudaPointerAttributes attributes = cudaPointerAttributes()
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
-    err = ccudart.cudaPointerGetAttributes(attributes._ptr, cptr_ptr)
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
+    err = cyruntime.cudaPointerGetAttributes(<cyruntime.cudaPointerAttributes*>attributes._ptr, cyptr_ptr)
     return (cudaError_t(err), attributes)
 {{endif}}
 
@@ -20040,7 +19884,7 @@ def cudaDeviceCanAccessPeer(int device, int peerDevice):
     :py:obj:`~.cudaDeviceEnablePeerAccess`, :py:obj:`~.cudaDeviceDisablePeerAccess`, :py:obj:`~.cuDeviceCanAccessPeer`
     """
     cdef int canAccessPeer = 0
-    err = ccudart.cudaDeviceCanAccessPeer(&canAccessPeer, device, peerDevice)
+    err = cyruntime.cudaDeviceCanAccessPeer(&canAccessPeer, device, peerDevice)
     return (cudaError_t(err), canAccessPeer)
 {{endif}}
 
@@ -20090,7 +19934,7 @@ def cudaDeviceEnablePeerAccess(int peerDevice, unsigned int flags):
     --------
     :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cudaDeviceDisablePeerAccess`, :py:obj:`~.cuCtxEnablePeerAccess`
     """
-    err = ccudart.cudaDeviceEnablePeerAccess(peerDevice, flags)
+    err = cyruntime.cudaDeviceEnablePeerAccess(peerDevice, flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20118,7 +19962,7 @@ def cudaDeviceDisablePeerAccess(int peerDevice):
     --------
     :py:obj:`~.cudaDeviceCanAccessPeer`, :py:obj:`~.cudaDeviceEnablePeerAccess`, :py:obj:`~.cuCtxDisablePeerAccess`
     """
-    err = ccudart.cudaDeviceDisablePeerAccess(peerDevice)
+    err = cyruntime.cudaDeviceDisablePeerAccess(peerDevice)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20148,17 +19992,16 @@ def cudaGraphicsUnregisterResource(resource):
     --------
     :py:obj:`~.cudaGraphicsD3D9RegisterResource`, :py:obj:`~.cudaGraphicsD3D10RegisterResource`, :py:obj:`~.cudaGraphicsD3D11RegisterResource`, :py:obj:`~.cudaGraphicsGLRegisterBuffer`, :py:obj:`~.cudaGraphicsGLRegisterImage`, :py:obj:`~.cuGraphicsUnregisterResource`
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
+    cdef cyruntime.cudaGraphicsResource_t cyresource
     if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
         presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     else:
         presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
-    err = ccudart.cudaGraphicsUnregisterResource(cresource)
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
+    err = cyruntime.cudaGraphicsUnregisterResource(cyresource)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20205,17 +20048,16 @@ def cudaGraphicsResourceSetMapFlags(resource, unsigned int flags):
     --------
     :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cuGraphicsResourceSetMapFlags`
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
+    cdef cyruntime.cudaGraphicsResource_t cyresource
     if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
         presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     else:
         presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
-    err = ccudart.cudaGraphicsResourceSetMapFlags(cresource, flags)
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
+    err = cyruntime.cudaGraphicsResourceSetMapFlags(cyresource, flags)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20259,28 +20101,26 @@ def cudaGraphicsMapResources(int count, resources, stream):
     --------
     :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaGraphicsUnmapResources`, :py:obj:`~.cuGraphicsMapResources`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaGraphicsResource_t *cresources
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaGraphicsResource_t *cyresources
     if resources is None:
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>NULL
-    elif isinstance(resources, (cudaGraphicsResource_t)):
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>NULL
+    elif isinstance(resources, (cudaGraphicsResource_t,)):
         presources = resources.getPtr()
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>presources
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>presources
     elif isinstance(resources, (int)):
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>resources
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>resources
     else:
-        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, cudart.cudaGraphicsResource_t'>, found " + str(type(resources)))
-
-    err = ccudart.cudaGraphicsMapResources(count, cresources, cstream)
+        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, runtime.cudaGraphicsResource_t'>, found " + str(type(resources)))
+    err = cyruntime.cudaGraphicsMapResources(count, cyresources, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20322,28 +20162,26 @@ def cudaGraphicsUnmapResources(int count, resources, stream):
     --------
     :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cuGraphicsUnmapResources`
     """
-    cdef ccudart.cudaStream_t cstream
+    cdef cyruntime.cudaStream_t cystream
     if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
         pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
         pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaGraphicsResource_t *cresources
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaGraphicsResource_t *cyresources
     if resources is None:
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>NULL
-    elif isinstance(resources, (cudaGraphicsResource_t)):
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>NULL
+    elif isinstance(resources, (cudaGraphicsResource_t,)):
         presources = resources.getPtr()
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>presources
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>presources
     elif isinstance(resources, (int)):
-        cresources = <ccudart.cudaGraphicsResource_t*><void_ptr>resources
+        cyresources = <cyruntime.cudaGraphicsResource_t*><void_ptr>resources
     else:
-        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, cudart.cudaGraphicsResource_t'>, found " + str(type(resources)))
-
-    err = ccudart.cudaGraphicsUnmapResources(count, cresources, cstream)
+        raise TypeError("Argument 'resources' is not instance of type (expected <class 'int, runtime.cudaGraphicsResource_t'>, found " + str(type(resources)))
+    err = cyruntime.cudaGraphicsUnmapResources(count, cyresources, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
@@ -20376,19 +20214,18 @@ def cudaGraphicsResourceGetMappedPointer(resource):
     size : int
         None
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
+    cdef cyruntime.cudaGraphicsResource_t cyresource
     if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
         presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     else:
         presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef void_ptr devPtr = 0
     cdef size_t size = 0
-    err = ccudart.cudaGraphicsResourceGetMappedPointer(<void**>&devPtr, &size, cresource)
+    err = cyruntime.cudaGraphicsResourceGetMappedPointer(<void**>&devPtr, &size, cyresource)
     return (cudaError_t(err), devPtr, size)
 {{endif}}
 
@@ -20433,18 +20270,17 @@ def cudaGraphicsSubResourceGetMappedArray(resource, unsigned int arrayIndex, uns
     --------
     :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsSubResourceGetMappedArray`
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
+    cdef cyruntime.cudaGraphicsResource_t cyresource
     if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
         presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     else:
         presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef cudaArray_t array = cudaArray_t()
-    err = ccudart.cudaGraphicsSubResourceGetMappedArray(array._ptr, cresource, arrayIndex, mipLevel)
+    err = cyruntime.cudaGraphicsSubResourceGetMappedArray(<cyruntime.cudaArray_t*>array._ptr, cyresource, arrayIndex, mipLevel)
     return (cudaError_t(err), array)
 {{endif}}
 
@@ -20478,18 +20314,17 @@ def cudaGraphicsResourceGetMappedMipmappedArray(resource):
     --------
     :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsResourceGetMappedMipmappedArray`
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
+    cdef cyruntime.cudaGraphicsResource_t cyresource
     if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
         presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     else:
         presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
     cdef cudaMipmappedArray_t mipmappedArray = cudaMipmappedArray_t()
-    err = ccudart.cudaGraphicsResourceGetMappedMipmappedArray(mipmappedArray._ptr, cresource)
+    err = cyruntime.cudaGraphicsResourceGetMappedMipmappedArray(<cyruntime.cudaMipmappedArray_t*>mipmappedArray._ptr, cyresource)
     return (cudaError_t(err), mipmappedArray)
 {{endif}}
 
@@ -20517,19 +20352,19 @@ def cudaGetChannelDesc(array):
     --------
     :py:obj:`~.cudaCreateChannelDesc (C API)`, :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cudaCreateSurfaceObject`
     """
-    cdef ccudart.cudaArray_const_t carray
+    cdef cyruntime.cudaArray_const_t cyarray
     if array is None:
-        carray = <ccudart.cudaArray_const_t><void_ptr>0
-    elif isinstance(array, (cudaArray_const_t)):
+        cyarray = <cyruntime.cudaArray_const_t><void_ptr>0
+    elif isinstance(array, (cudaArray_const_t,)):
         parray = int(array)
-        carray = <ccudart.cudaArray_const_t><void_ptr>parray
+        cyarray = <cyruntime.cudaArray_const_t><void_ptr>parray
     else:
         parray = int(cudaArray_const_t(array))
-        carray = <ccudart.cudaArray_const_t><void_ptr>parray
-
+        cyarray = <cyruntime.cudaArray_const_t><void_ptr>parray
     cdef cudaChannelFormatDesc desc = cudaChannelFormatDesc()
     with nogil:
-        err = ccudart.cudaGetChannelDesc(desc._ptr, carray)
+        err = cyruntime.cudaGetChannelDesc(<cyruntime.cudaChannelFormatDesc*>desc._ptr, cyarray)
+
     return (cudaError_t(err), desc)
 {{endif}}
 
@@ -20574,9 +20409,8 @@ def cudaCreateChannelDesc(int x, int y, int z, int w, f not None : cudaChannelFo
     --------
     cudaCreateChannelDesc (C++ API), :py:obj:`~.cudaGetChannelDesc`, :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cudaCreateSurfaceObject`
     """
-    cdef ccudart.cudaChannelFormatKind cf = f.value
-    cdef ccudart.cudaChannelFormatDesc err
-    err = ccudart.cudaCreateChannelDesc(x, y, z, w, cf)
+    cdef cyruntime.cudaChannelFormatKind cyf = f.value
+    err = cyruntime.cudaCreateChannelDesc(x, y, z, w, cyf)
     cdef cudaChannelFormatDesc wrapper = cudaChannelFormatDesc()
     wrapper._ptr[0] = err
     return (cudaError_t.cudaSuccess, wrapper)
@@ -20802,17 +20636,17 @@ def cudaCreateTextureObject(pResDesc : Optional[cudaResourceDesc], pTexDesc : Op
     :py:obj:`~.cudaDestroyTextureObject`, :py:obj:`~.cuTexObjectCreate`
     """
     cdef cudaTextureObject_t pTexObject = cudaTextureObject_t()
-    cdef ccudart.cudaResourceDesc* cpResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
-    cdef ccudart.cudaTextureDesc* cpTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
-    cdef ccudart.cudaResourceViewDesc* cpResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
-    err = ccudart.cudaCreateTextureObject(pTexObject._ptr, cpResDesc_ptr, cpTexDesc_ptr, cpResViewDesc_ptr)
+    cdef cyruntime.cudaResourceDesc* cypResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
+    cdef cyruntime.cudaTextureDesc* cypTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
+    cdef cyruntime.cudaResourceViewDesc* cypResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
+    err = cyruntime.cudaCreateTextureObject(<cyruntime.cudaTextureObject_t*>pTexObject._ptr, cypResDesc_ptr, cypTexDesc_ptr, cypResViewDesc_ptr)
     return (cudaError_t(err), pTexObject)
 {{endif}}
 
 {{if 'cudaCreateTextureObject_v2' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaCreateTextureObject_v2(pResDesc : cudaResourceDesc, pTexDesc : cudaTextureDesc_v2, pResViewDesc : cudaResourceViewDesc):
+def cudaCreateTextureObject_v2(pResDesc : Optional[cudaResourceDesc], pTexDesc : Optional[cudaTextureDesc_v2], pResViewDesc : Optional[cudaResourceViewDesc]):
     """ Creates a texture object.
 
     Creates a texture object and returns it in `pTexObject`. `pResDesc`
@@ -21018,502 +20852,1088 @@ def cudaCreateTextureObject_v2(pResDesc : cudaResourceDesc, pTexDesc : cudaTextu
       index for layered textures. This will be the new layer zero. For non-
       layered resources, this value has to be zero.
 
-    - :py:obj:`~.cudaResourceViewDesc.lastLayer` specifies the last layer
-      index for layered textures. For non-layered resources, this value has
-      to be zero.
+    - :py:obj:`~.cudaResourceViewDesc.lastLayer` specifies the last layer
+      index for layered textures. For non-layered resources, this value has
+      to be zero.
+
+    Parameters
+    ----------
+    pResDesc : :py:obj:`~.cudaResourceDesc`
+        Resource descriptor
+    pTexDesc : :py:obj:`~.cudaTextureDesc_v2`
+        Texture descriptor
+    pResViewDesc : :py:obj:`~.cudaResourceViewDesc`
+        Resource view descriptor
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pTexObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object to create
+
+    See Also
+    --------
+    :py:obj:`~.cudaDestroyTextureObject`, :py:obj:`~.cuTexObjectCreate`
+    """
+    cdef cudaTextureObject_t pTexObject = cudaTextureObject_t()
+    cdef cyruntime.cudaResourceDesc* cypResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
+    cdef cyruntime.cudaTextureDesc_v2* cypTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
+    cdef cyruntime.cudaResourceViewDesc* cypResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
+    err = cyruntime.cudaCreateTextureObject_v2(<cyruntime.cudaTextureObject_t*>pTexObject._ptr, cypResDesc_ptr, cypTexDesc_ptr, cypResViewDesc_ptr)
+    return (cudaError_t(err), pTexObject)
+{{endif}}
+
+{{if 'cudaDestroyTextureObject' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaDestroyTextureObject(texObject):
+    """ Destroys a texture object.
+
+    Destroys the texture object specified by `texObject`.
+
+    Parameters
+    ----------
+    texObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object to destroy
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectDestroy`
+    """
+    cdef cyruntime.cudaTextureObject_t cytexObject
+    if texObject is None:
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>0
+    elif isinstance(texObject, (cudaTextureObject_t,)):
+        ptexObject = int(texObject)
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    else:
+        ptexObject = int(cudaTextureObject_t(texObject))
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    with nogil:
+        err = cyruntime.cudaDestroyTextureObject(cytexObject)
+
+    return (cudaError_t(err),)
+{{endif}}
+
+{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGetTextureObjectResourceDesc(texObject):
+    """ Returns a texture object's resource descriptor.
+
+    Returns the resource descriptor for the texture object specified by
+    `texObject`.
+
+    Parameters
+    ----------
+    texObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pResDesc : :py:obj:`~.cudaResourceDesc`
+        Resource descriptor
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetResourceDesc`
+    """
+    cdef cyruntime.cudaTextureObject_t cytexObject
+    if texObject is None:
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>0
+    elif isinstance(texObject, (cudaTextureObject_t,)):
+        ptexObject = int(texObject)
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    else:
+        ptexObject = int(cudaTextureObject_t(texObject))
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cudaResourceDesc pResDesc = cudaResourceDesc()
+    with nogil:
+        err = cyruntime.cudaGetTextureObjectResourceDesc(<cyruntime.cudaResourceDesc*>pResDesc._ptr, cytexObject)
+
+    return (cudaError_t(err), pResDesc)
+{{endif}}
+
+{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGetTextureObjectTextureDesc(texObject):
+    """ Returns a texture object's texture descriptor.
+
+    Returns the texture descriptor for the texture object specified by
+    `texObject`.
+
+    Parameters
+    ----------
+    texObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pTexDesc : :py:obj:`~.cudaTextureDesc`
+        Texture descriptor
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetTextureDesc`
+    """
+    cdef cyruntime.cudaTextureObject_t cytexObject
+    if texObject is None:
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>0
+    elif isinstance(texObject, (cudaTextureObject_t,)):
+        ptexObject = int(texObject)
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    else:
+        ptexObject = int(cudaTextureObject_t(texObject))
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cudaTextureDesc pTexDesc = cudaTextureDesc()
+    with nogil:
+        err = cyruntime.cudaGetTextureObjectTextureDesc(<cyruntime.cudaTextureDesc*>pTexDesc._ptr, cytexObject)
+
+    return (cudaError_t(err), pTexDesc)
+{{endif}}
+
+{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGetTextureObjectTextureDesc_v2(texObject):
+    """ Returns a texture object's texture descriptor.
+
+    Returns the texture descriptor for the texture object specified by
+    `texObject`.
+
+    Parameters
+    ----------
+    texObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pTexDesc : :py:obj:`~.cudaTextureDesc_v2`
+        Texture descriptor
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetTextureDesc`
+    """
+    cdef cyruntime.cudaTextureObject_t cytexObject
+    if texObject is None:
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>0
+    elif isinstance(texObject, (cudaTextureObject_t,)):
+        ptexObject = int(texObject)
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    else:
+        ptexObject = int(cudaTextureObject_t(texObject))
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cudaTextureDesc_v2 pTexDesc = cudaTextureDesc_v2()
+    err = cyruntime.cudaGetTextureObjectTextureDesc_v2(<cyruntime.cudaTextureDesc_v2*>pTexDesc._ptr, cytexObject)
+    return (cudaError_t(err), pTexDesc)
+{{endif}}
+
+{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGetTextureObjectResourceViewDesc(texObject):
+    """ Returns a texture object's resource view descriptor.
+
+    Returns the resource view descriptor for the texture object specified
+    by `texObject`. If no resource view was specified,
+    :py:obj:`~.cudaErrorInvalidValue` is returned.
+
+    Parameters
+    ----------
+    texObject : :py:obj:`~.cudaTextureObject_t`
+        Texture object
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pResViewDesc : :py:obj:`~.cudaResourceViewDesc`
+        Resource view descriptor
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetResourceViewDesc`
+    """
+    cdef cyruntime.cudaTextureObject_t cytexObject
+    if texObject is None:
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>0
+    elif isinstance(texObject, (cudaTextureObject_t,)):
+        ptexObject = int(texObject)
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    else:
+        ptexObject = int(cudaTextureObject_t(texObject))
+        cytexObject = <cyruntime.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cudaResourceViewDesc pResViewDesc = cudaResourceViewDesc()
+    err = cyruntime.cudaGetTextureObjectResourceViewDesc(<cyruntime.cudaResourceViewDesc*>pResViewDesc._ptr, cytexObject)
+    return (cudaError_t(err), pResViewDesc)
+{{endif}}
+
+{{if 'cudaCreateSurfaceObject' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaCreateSurfaceObject(pResDesc : Optional[cudaResourceDesc]):
+    """ Creates a surface object.
+
+    Creates a surface object and returns it in `pSurfObject`. `pResDesc`
+    describes the data to perform surface load/stores on.
+    :py:obj:`~.cudaResourceDesc.resType` must be
+    :py:obj:`~.cudaResourceTypeArray` and
+    :py:obj:`~.cudaResourceDesc`::res::array::array must be set to a valid
+    CUDA array handle.
+
+    Surface objects are only supported on devices of compute capability 3.0
+    or higher. Additionally, a surface object is an opaque value, and, as
+    such, should only be accessed through CUDA API calls.
+
+    Parameters
+    ----------
+    pResDesc : :py:obj:`~.cudaResourceDesc`
+        Resource descriptor
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidResourceHandle`
+    pSurfObject : :py:obj:`~.cudaSurfaceObject_t`
+        Surface object to create
+
+    See Also
+    --------
+    :py:obj:`~.cudaDestroySurfaceObject`, :py:obj:`~.cuSurfObjectCreate`
+    """
+    cdef cudaSurfaceObject_t pSurfObject = cudaSurfaceObject_t()
+    cdef cyruntime.cudaResourceDesc* cypResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
+    with nogil:
+        err = cyruntime.cudaCreateSurfaceObject(<cyruntime.cudaSurfaceObject_t*>pSurfObject._ptr, cypResDesc_ptr)
+
+    return (cudaError_t(err), pSurfObject)
+{{endif}}
+
+{{if 'cudaDestroySurfaceObject' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaDestroySurfaceObject(surfObject):
+    """ Destroys a surface object.
+
+    Destroys the surface object specified by `surfObject`.
+
+    Parameters
+    ----------
+    surfObject : :py:obj:`~.cudaSurfaceObject_t`
+        Surface object to destroy
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateSurfaceObject`, :py:obj:`~.cuSurfObjectDestroy`
+    """
+    cdef cyruntime.cudaSurfaceObject_t cysurfObject
+    if surfObject is None:
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>0
+    elif isinstance(surfObject, (cudaSurfaceObject_t,)):
+        psurfObject = int(surfObject)
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>psurfObject
+    else:
+        psurfObject = int(cudaSurfaceObject_t(surfObject))
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>psurfObject
+    with nogil:
+        err = cyruntime.cudaDestroySurfaceObject(cysurfObject)
+
+    return (cudaError_t(err),)
+{{endif}}
+
+{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGetSurfaceObjectResourceDesc(surfObject):
+    """ Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by `surfObject`.
+
+    Parameters
+    ----------
+    surfObject : :py:obj:`~.cudaSurfaceObject_t`
+        Surface object
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pResDesc : :py:obj:`~.cudaResourceDesc`
+        Resource descriptor
+
+    See Also
+    --------
+    :py:obj:`~.cudaCreateSurfaceObject`, :py:obj:`~.cuSurfObjectGetResourceDesc`
+    """
+    cdef cyruntime.cudaSurfaceObject_t cysurfObject
+    if surfObject is None:
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>0
+    elif isinstance(surfObject, (cudaSurfaceObject_t,)):
+        psurfObject = int(surfObject)
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>psurfObject
+    else:
+        psurfObject = int(cudaSurfaceObject_t(surfObject))
+        cysurfObject = <cyruntime.cudaSurfaceObject_t><void_ptr>psurfObject
+    cdef cudaResourceDesc pResDesc = cudaResourceDesc()
+    err = cyruntime.cudaGetSurfaceObjectResourceDesc(<cyruntime.cudaResourceDesc*>pResDesc._ptr, cysurfObject)
+    return (cudaError_t(err), pResDesc)
+{{endif}}
+
+{{if 'cudaDriverGetVersion' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaDriverGetVersion():
+    """ Returns the latest version of CUDA supported by the driver.
+
+    Returns in `*driverVersion` the latest version of CUDA supported by the
+    driver. The version is returned as (1000 * major + 10 * minor). For
+    example, CUDA 9.2 would be represented by 9020. If no driver is
+    installed, then 0 is returned as the driver version.
+
+    This function automatically returns :py:obj:`~.cudaErrorInvalidValue`
+    if `driverVersion` is NULL.
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    driverVersion : int
+        Returns the CUDA driver version.
+
+    See Also
+    --------
+    :py:obj:`~.cudaRuntimeGetVersion`, :py:obj:`~.cuDriverGetVersion`
+    """
+    cdef int driverVersion = 0
+    err = cyruntime.cudaDriverGetVersion(&driverVersion)
+    return (cudaError_t(err), driverVersion)
+{{endif}}
+
+{{if 'cudaRuntimeGetVersion' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaRuntimeGetVersion():
+    """ Returns the CUDA Runtime version.
+
+    Returns in `*runtimeVersion` the version number of the current CUDA
+    Runtime instance. The version is returned as (1000 * major + 10 *
+    minor). For example, CUDA 9.2 would be represented by 9020.
+
+    This function automatically returns :py:obj:`~.cudaErrorInvalidValue`
+    if the `runtimeVersion` argument is NULL.
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    runtimeVersion : int
+        Returns the CUDA Runtime version.
+
+    See Also
+    --------
+    :py:obj:`~.cudaDriverGetVersion`, :py:obj:`~.cuDriverGetVersion`
+    """
+    cdef int runtimeVersion = 0
+    err = cyruntime.cudaRuntimeGetVersion(&runtimeVersion)
+    return (cudaError_t(err), runtimeVersion)
+{{endif}}
+
+{{if 'cudaGraphCreate' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGraphCreate(unsigned int flags):
+    """ Creates a graph.
+
+    Creates an empty graph, which is returned via `pGraph`.
 
     Parameters
     ----------
-    pResDesc : :py:obj:`~.cudaResourceDesc`
-        Resource descriptor
-    pTexDesc : :py:obj:`~.cudaTextureDesc_v2`
-        Texture descriptor
-    pResViewDesc : :py:obj:`~.cudaResourceViewDesc`
-        Resource view descriptor
+    flags : unsigned int
+        Graph creation flags, must be 0
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pTexObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object to create
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
+    pGraph : :py:obj:`~.cudaGraph_t`
+        Returns newly created graph
 
     See Also
     --------
-    :py:obj:`~.cudaDestroyTextureObject`, :py:obj:`~.cuTexObjectCreate`
+    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphDestroy`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphClone`
     """
-    cdef cudaTextureObject_t pTexObject = cudaTextureObject_t()
-    cdef ccudart.cudaResourceDesc* cpResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
-    cdef ccudart.cudaTextureDesc_v2* cpTexDesc_ptr = pTexDesc._ptr if pTexDesc != None else NULL
-    cdef ccudart.cudaResourceViewDesc* cpResViewDesc_ptr = pResViewDesc._ptr if pResViewDesc != None else NULL
-    err = ccudart.cudaCreateTextureObject_v2(pTexObject._ptr, cpResDesc_ptr, cpTexDesc_ptr, cpResViewDesc_ptr)
-    return (cudaError_t(err), pTexObject)
+    cdef cudaGraph_t pGraph = cudaGraph_t()
+    err = cyruntime.cudaGraphCreate(<cyruntime.cudaGraph_t*>pGraph._ptr, flags)
+    return (cudaError_t(err), pGraph)
 {{endif}}
 
-{{if 'cudaDestroyTextureObject' in found_functions}}
+{{if 'cudaGraphAddKernelNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDestroyTextureObject(texObject):
-    """ Destroys a texture object.
+def cudaGraphAddKernelNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaKernelNodeParams]):
+    """ Creates a kernel execution node and adds it to a graph.
 
-    Destroys the texture object specified by `texObject`.
+    Creates a new kernel execution node and adds it to `graph` with
+    `numDependencies` dependencies specified via `pDependencies` and
+    arguments specified in `pNodeParams`. It is possible for
+    `numDependencies` to be 0, in which case the node will be placed at the
+    root of the graph. `pDependencies` may not have any duplicate entries.
+    A handle to the new node will be returned in `pGraphNode`.
+
+    The :py:obj:`~.cudaKernelNodeParams` structure is defined as:
+
+    **View CUDA Toolkit Documentation for a C++ code example**
+
+    When the graph is launched, the node will invoke kernel `func` on a
+    (`gridDim.x` x `gridDim.y` x `gridDim.z`) grid of blocks. Each block
+    contains (`blockDim.x` x `blockDim.y` x `blockDim.z`) threads.
+
+    `sharedMem` sets the amount of dynamic shared memory that will be
+    available to each thread block.
+
+    Kernel parameters to `func` can be specified in one of two ways:
+
+    1) Kernel parameters can be specified via `kernelParams`. If the kernel
+    has N parameters, then `kernelParams` needs to be an array of N
+    pointers. Each pointer, from `kernelParams`[0] to `kernelParams`[N-1],
+    points to the region of memory from which the actual parameter will be
+    copied. The number of kernel parameters and their offsets and sizes do
+    not need to be specified as that information is retrieved directly from
+    the kernel's image.
+
+    2) Kernel parameters can also be packaged by the application into a
+    single buffer that is passed in via `extra`. This places the burden on
+    the application of knowing each kernel parameter's size and
+    alignment/padding within the buffer. The `extra` parameter exists to
+    allow this function to take additional less commonly used arguments.
+    `extra` specifies a list of names of extra settings and their
+    corresponding values. Each extra setting name is immediately followed
+    by the corresponding value. The list must be terminated with either
+    NULL or CU_LAUNCH_PARAM_END.
+
+    - :py:obj:`~.CU_LAUNCH_PARAM_END`, which indicates the end of the
+      `extra` array;
+
+    - :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER`, which specifies that the
+      next value in `extra` will be a pointer to a buffer containing all
+      the kernel parameters for launching kernel `func`;
+
+    - :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE`, which specifies that the
+      next value in `extra` will be a pointer to a size_t containing the
+      size of the buffer specified with
+      :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER`;
+
+    The error :py:obj:`~.cudaErrorInvalidValue` will be returned if kernel
+    parameters are specified with both `kernelParams` and `extra` (i.e.
+    both `kernelParams` and `extra` are non-NULL).
+
+    The `kernelParams` or `extra` array, as well as the argument values it
+    points to, are copied during this call.
 
     Parameters
     ----------
-    texObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object to destroy
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which to add the node
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Dependencies of the node
+    numDependencies : size_t
+        Number of dependencies
+    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+        Parameters for the GPU execution node
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDeviceFunction`
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
+        Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectDestroy`
+    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphKernelNodeGetParams`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+
+    Notes
+    -----
+    Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
     """
-    cdef ccudart.cudaTextureObject_t ctexObject
-    if texObject is None:
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>0
-    elif isinstance(texObject, (cudaTextureObject_t)):
-        ptexObject = int(texObject)
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
+    pDependencies = [] if pDependencies is None else pDependencies
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        ptexObject = int(cudaTextureObject_t(texObject))
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
-
-    with nogil:
-        err = ccudart.cudaDestroyTextureObject(ctexObject)
-    return (cudaError_t(err),)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    if len(pDependencies) > 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(pDependencies)):
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
+    cdef cyruntime.cudaKernelNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphAddKernelNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypNodeParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGetTextureObjectResourceDesc' in found_functions}}
+{{if 'cudaGraphKernelNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetTextureObjectResourceDesc(texObject):
-    """ Returns a texture object's resource descriptor.
+def cudaGraphKernelNodeGetParams(node):
+    """ Returns a kernel node's parameters.
 
-    Returns the resource descriptor for the texture object specified by
-    `texObject`.
+    Returns the parameters of kernel node `node` in `pNodeParams`. The
+    `kernelParams` or `extra` array returned in `pNodeParams`, as well as
+    the argument values it points to, are owned by the node. This memory
+    remains valid until the node is destroyed or its parameters are
+    modified, and should not be modified directly. Use
+    :py:obj:`~.cudaGraphKernelNodeSetParams` to update the parameters of
+    this node.
+
+    The params will contain either `kernelParams` or `extra`, according to
+    which of these was most recently set on the node.
 
     Parameters
     ----------
-    texObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pResDesc : :py:obj:`~.cudaResourceDesc`
-        Resource descriptor
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDeviceFunction`
+    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+        Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetResourceDesc`
+    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeSetParams`
     """
-    cdef ccudart.cudaTextureObject_t ctexObject
-    if texObject is None:
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>0
-    elif isinstance(texObject, (cudaTextureObject_t)):
-        ptexObject = int(texObject)
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        ptexObject = int(cudaTextureObject_t(texObject))
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
-
-    cdef cudaResourceDesc pResDesc = cudaResourceDesc()
-    with nogil:
-        err = ccudart.cudaGetTextureObjectResourceDesc(pResDesc._ptr, ctexObject)
-    return (cudaError_t(err), pResDesc)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaKernelNodeParams pNodeParams = cudaKernelNodeParams()
+    err = cyruntime.cudaGraphKernelNodeGetParams(cynode, <cyruntime.cudaKernelNodeParams*>pNodeParams._ptr)
+    return (cudaError_t(err), pNodeParams)
 {{endif}}
 
-{{if 'cudaGetTextureObjectTextureDesc' in found_functions}}
+{{if 'cudaGraphKernelNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetTextureObjectTextureDesc(texObject):
-    """ Returns a texture object's texture descriptor.
+def cudaGraphKernelNodeSetParams(node, pNodeParams : Optional[cudaKernelNodeParams]):
+    """ Sets a kernel node's parameters.
 
-    Returns the texture descriptor for the texture object specified by
-    `texObject`.
+    Sets the parameters of kernel node `node` to `pNodeParams`.
 
     Parameters
     ----------
-    texObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the parameters for
+    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+        Parameters to copy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pTexDesc : :py:obj:`~.cudaTextureDesc`
-        Texture descriptor
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorMemoryAllocation`
 
     See Also
     --------
-    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetTextureDesc`
+    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeGetParams`
     """
-    cdef ccudart.cudaTextureObject_t ctexObject
-    if texObject is None:
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>0
-    elif isinstance(texObject, (cudaTextureObject_t)):
-        ptexObject = int(texObject)
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        ptexObject = int(cudaTextureObject_t(texObject))
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
-
-    cdef cudaTextureDesc pTexDesc = cudaTextureDesc()
-    with nogil:
-        err = ccudart.cudaGetTextureObjectTextureDesc(pTexDesc._ptr, ctexObject)
-    return (cudaError_t(err), pTexDesc)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaKernelNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphKernelNodeSetParams(cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGetTextureObjectTextureDesc_v2' in found_functions}}
+{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetTextureObjectTextureDesc_v2(texObject):
-    """ Returns a texture object's texture descriptor.
+def cudaGraphKernelNodeCopyAttributes(hSrc, hDst):
+    """ Copies attributes from source node to destination node.
 
-    Returns the texture descriptor for the texture object specified by
-    `texObject`.
+    Copies attributes from source node `src` to destination node `dst`.
+    Both node must have the same context.
 
     Parameters
     ----------
-    texObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object
+    dst : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Destination node
+    src : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Source node For list of attributes see
+        :py:obj:`~.cudaKernelNodeAttrID`
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pTexDesc : :py:obj:`~.cudaTextureDesc_v2`
-        Texture descriptor
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidContext`
 
     See Also
     --------
-    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetTextureDesc`
+    :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef ccudart.cudaTextureObject_t ctexObject
-    if texObject is None:
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>0
-    elif isinstance(texObject, (cudaTextureObject_t)):
-        ptexObject = int(texObject)
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cyruntime.cudaGraphNode_t cyhDst
+    if hDst is None:
+        cyhDst = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hDst, (cudaGraphNode_t,driver.CUgraphNode)):
+        phDst = int(hDst)
+        cyhDst = <cyruntime.cudaGraphNode_t><void_ptr>phDst
     else:
-        ptexObject = int(cudaTextureObject_t(texObject))
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
-
-    cdef cudaTextureDesc_v2 pTexDesc = cudaTextureDesc_v2()
-    err = ccudart.cudaGetTextureObjectTextureDesc_v2(pTexDesc._ptr, ctexObject)
-    return (cudaError_t(err), pTexDesc)
+        phDst = int(cudaGraphNode_t(hDst))
+        cyhDst = <cyruntime.cudaGraphNode_t><void_ptr>phDst
+    cdef cyruntime.cudaGraphNode_t cyhSrc
+    if hSrc is None:
+        cyhSrc = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hSrc, (cudaGraphNode_t,driver.CUgraphNode)):
+        phSrc = int(hSrc)
+        cyhSrc = <cyruntime.cudaGraphNode_t><void_ptr>phSrc
+    else:
+        phSrc = int(cudaGraphNode_t(hSrc))
+        cyhSrc = <cyruntime.cudaGraphNode_t><void_ptr>phSrc
+    err = cyruntime.cudaGraphKernelNodeCopyAttributes(cyhSrc, cyhDst)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGetTextureObjectResourceViewDesc' in found_functions}}
+{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetTextureObjectResourceViewDesc(texObject):
-    """ Returns a texture object's resource view descriptor.
+def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID):
+    """ Queries node attribute.
 
-    Returns the resource view descriptor for the texture object specified
-    by `texObject`. If no resource view was specified,
-    :py:obj:`~.cudaErrorInvalidValue` is returned.
+    Queries attribute `attr` from node `hNode` and stores it in
+    corresponding member of `value_out`.
 
     Parameters
     ----------
-    texObject : :py:obj:`~.cudaTextureObject_t`
-        Texture object
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+
+    attr : :py:obj:`~.cudaKernelNodeAttrID`
+
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pResViewDesc : :py:obj:`~.cudaResourceViewDesc`
-        Resource view descriptor
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`
+    value_out : :py:obj:`~.cudaKernelNodeAttrValue`
+
 
     See Also
     --------
-    :py:obj:`~.cudaCreateTextureObject`, :py:obj:`~.cuTexObjectGetResourceViewDesc`
+    :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef ccudart.cudaTextureObject_t ctexObject
-    if texObject is None:
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>0
-    elif isinstance(texObject, (cudaTextureObject_t)):
-        ptexObject = int(texObject)
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        ptexObject = int(cudaTextureObject_t(texObject))
-        ctexObject = <ccudart.cudaTextureObject_t><void_ptr>ptexObject
-
-    cdef cudaResourceViewDesc pResViewDesc = cudaResourceViewDesc()
-    err = ccudart.cudaGetTextureObjectResourceViewDesc(pResViewDesc._ptr, ctexObject)
-    return (cudaError_t(err), pResViewDesc)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaKernelNodeAttrID cyattr = attr.value
+    cdef cudaKernelNodeAttrValue value_out = cudaKernelNodeAttrValue()
+    err = cyruntime.cudaGraphKernelNodeGetAttribute(cyhNode, cyattr, <cyruntime.cudaKernelNodeAttrValue*>value_out._ptr)
+    return (cudaError_t(err), value_out)
 {{endif}}
 
-{{if 'cudaCreateSurfaceObject' in found_functions}}
+{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaCreateSurfaceObject(pResDesc : Optional[cudaResourceDesc]):
-    """ Creates a surface object.
-
-    Creates a surface object and returns it in `pSurfObject`. `pResDesc`
-    describes the data to perform surface load/stores on.
-    :py:obj:`~.cudaResourceDesc.resType` must be
-    :py:obj:`~.cudaResourceTypeArray` and
-    :py:obj:`~.cudaResourceDesc`::res::array::array must be set to a valid
-    CUDA array handle.
+def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID, value : Optional[cudaKernelNodeAttrValue]):
+    """ Sets node attribute.
 
-    Surface objects are only supported on devices of compute capability 3.0
-    or higher. Additionally, a surface object is an opaque value, and, as
-    such, should only be accessed through CUDA API calls.
+    Sets attribute `attr` on node `hNode` from corresponding attribute of
+    `value`.
 
     Parameters
     ----------
-    pResDesc : :py:obj:`~.cudaResourceDesc`
-        Resource descriptor
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+
+    attr : :py:obj:`~.cudaKernelNodeAttrID`
+
+    value : :py:obj:`~.cudaKernelNodeAttrValue`
+
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidChannelDescriptor`, :py:obj:`~.cudaErrorInvalidResourceHandle`
-    pSurfObject : :py:obj:`~.cudaSurfaceObject_t`
-        Surface object to create
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`
 
     See Also
     --------
-    :py:obj:`~.cudaDestroySurfaceObject`, :py:obj:`~.cuSurfObjectCreate`
+    :py:obj:`~.cudaAccessPolicyWindow`
     """
-    cdef cudaSurfaceObject_t pSurfObject = cudaSurfaceObject_t()
-    cdef ccudart.cudaResourceDesc* cpResDesc_ptr = pResDesc._ptr if pResDesc != None else NULL
-    with nogil:
-        err = ccudart.cudaCreateSurfaceObject(pSurfObject._ptr, cpResDesc_ptr)
-    return (cudaError_t(err), pSurfObject)
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    else:
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaKernelNodeAttrID cyattr = attr.value
+    cdef cyruntime.cudaKernelNodeAttrValue* cyvalue_ptr = value._ptr if value != None else NULL
+    err = cyruntime.cudaGraphKernelNodeSetAttribute(cyhNode, cyattr, cyvalue_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDestroySurfaceObject' in found_functions}}
+{{if 'cudaGraphAddMemcpyNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDestroySurfaceObject(surfObject):
-    """ Destroys a surface object.
+def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, pCopyParams : Optional[cudaMemcpy3DParms]):
+    """ Creates a memcpy node and adds it to a graph.
 
-    Destroys the surface object specified by `surfObject`.
+    Creates a new memcpy node and adds it to `graph` with `numDependencies`
+    dependencies specified via `pDependencies`. It is possible for
+    `numDependencies` to be 0, in which case the node will be placed at the
+    root of the graph. `pDependencies` may not have any duplicate entries.
+    A handle to the new node will be returned in `pGraphNode`.
+
+    When the graph is launched, the node will perform the memcpy described
+    by `pCopyParams`. See :py:obj:`~.cudaMemcpy3D()` for a description of
+    the structure and its restrictions.
+
+    Memcpy nodes have some additional restrictions with regards to managed
+    memory, if the system contains at least one device which has a zero
+    value for the device attribute
+    :py:obj:`~.cudaDevAttrConcurrentManagedAccess`.
 
     Parameters
     ----------
-    surfObject : :py:obj:`~.cudaSurfaceObject_t`
-        Surface object to destroy
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which to add the node
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Dependencies of the node
+    numDependencies : size_t
+        Number of dependencies
+    pCopyParams : :py:obj:`~.cudaMemcpy3DParms`
+        Parameters for the memory copy
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
+        Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaCreateSurfaceObject`, :py:obj:`~.cuSurfObjectDestroy`
+    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphAddMemcpyNodeToSymbol`, :py:obj:`~.cudaGraphAddMemcpyNodeFromSymbol`, :py:obj:`~.cudaGraphAddMemcpyNode1D`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaSurfaceObject_t csurfObject
-    if surfObject is None:
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>0
-    elif isinstance(surfObject, (cudaSurfaceObject_t)):
-        psurfObject = int(surfObject)
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>psurfObject
+    pDependencies = [] if pDependencies is None else pDependencies
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        psurfObject = int(cudaSurfaceObject_t(surfObject))
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>psurfObject
-
-    with nogil:
-        err = ccudart.cudaDestroySurfaceObject(csurfObject)
-    return (cudaError_t(err),)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    if len(pDependencies) > 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(pDependencies)):
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
+    cdef cyruntime.cudaMemcpy3DParms* cypCopyParams_ptr = pCopyParams._ptr if pCopyParams != None else NULL
+    err = cyruntime.cudaGraphAddMemcpyNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypCopyParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGetSurfaceObjectResourceDesc' in found_functions}}
+{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGetSurfaceObjectResourceDesc(surfObject):
-    """ Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by `surfObject`.
+def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, dst, src, size_t count, kind not None : cudaMemcpyKind):
+    """ Creates a 1D memcpy node and adds it to a graph.
+
+    Creates a new 1D memcpy node and adds it to `graph` with
+    `numDependencies` dependencies specified via `pDependencies`. It is
+    possible for `numDependencies` to be 0, in which case the node will be
+    placed at the root of the graph. `pDependencies` may not have any
+    duplicate entries. A handle to the new node will be returned in
+    `pGraphNode`.
+
+    When the graph is launched, the node will copy `count` bytes from the
+    memory area pointed to by `src` to the memory area pointed to by `dst`,
+    where `kind` specifies the direction of the copy, and must be one of
+    :py:obj:`~.cudaMemcpyHostToHost`, :py:obj:`~.cudaMemcpyHostToDevice`,
+    :py:obj:`~.cudaMemcpyDeviceToHost`,
+    :py:obj:`~.cudaMemcpyDeviceToDevice`, or :py:obj:`~.cudaMemcpyDefault`.
+    Passing :py:obj:`~.cudaMemcpyDefault` is recommended, in which case the
+    type of transfer is inferred from the pointer values. However,
+    :py:obj:`~.cudaMemcpyDefault` is only allowed on systems that support
+    unified virtual addressing. Launching a memcpy node with dst and src
+    pointers that do not match the direction of the copy results in an
+    undefined behavior.
+
+    Memcpy nodes have some additional restrictions with regards to managed
+    memory, if the system contains at least one device which has a zero
+    value for the device attribute
+    :py:obj:`~.cudaDevAttrConcurrentManagedAccess`.
 
     Parameters
     ----------
-    surfObject : :py:obj:`~.cudaSurfaceObject_t`
-        Surface object
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which to add the node
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Dependencies of the node
+    numDependencies : size_t
+        Number of dependencies
+    dst : Any
+        Destination memory address
+    src : Any
+        Source memory address
+    count : size_t
+        Size in bytes to copy
+    kind : :py:obj:`~.cudaMemcpyKind`
+        Type of transfer
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pResDesc : :py:obj:`~.cudaResourceDesc`
-        Resource descriptor
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
+        Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaCreateSurfaceObject`, :py:obj:`~.cuSurfObjectGetResourceDesc`
+    :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaSurfaceObject_t csurfObject
-    if surfObject is None:
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>0
-    elif isinstance(surfObject, (cudaSurfaceObject_t)):
-        psurfObject = int(surfObject)
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>psurfObject
+    pDependencies = [] if pDependencies is None else pDependencies
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        psurfObject = int(cudaSurfaceObject_t(surfObject))
-        csurfObject = <ccudart.cudaSurfaceObject_t><void_ptr>psurfObject
-
-    cdef cudaResourceDesc pResDesc = cudaResourceDesc()
-    err = ccudart.cudaGetSurfaceObjectResourceDesc(pResDesc._ptr, csurfObject)
-    return (cudaError_t(err), pResDesc)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    if len(pDependencies) > 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(pDependencies)):
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaGraphAddMemcpyNode1D(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cydst_ptr, cysrc_ptr, count, cykind)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaDriverGetVersion' in found_functions}}
+{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDriverGetVersion():
-    """ Returns the latest version of CUDA supported by the driver.
+def cudaGraphMemcpyNodeGetParams(node):
+    """ Returns a memcpy node's parameters.
 
-    Returns in `*driverVersion` the latest version of CUDA supported by the
-    driver. The version is returned as (1000 * major + 10 * minor). For
-    example, CUDA 9.2 would be represented by 9020. If no driver is
-    installed, then 0 is returned as the driver version.
+    Returns the parameters of memcpy node `node` in `pNodeParams`.
 
-    This function automatically returns :py:obj:`~.cudaErrorInvalidValue`
-    if `driverVersion` is NULL.
+    Parameters
+    ----------
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    driverVersion : int
-        Returns the CUDA driver version.
+    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
+        Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaRuntimeGetVersion`, :py:obj:`~.cuDriverGetVersion`
+    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`
     """
-    cdef int driverVersion = 0
-    err = ccudart.cudaDriverGetVersion(&driverVersion)
-    return (cudaError_t(err), driverVersion)
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaMemcpy3DParms pNodeParams = cudaMemcpy3DParms()
+    err = cyruntime.cudaGraphMemcpyNodeGetParams(cynode, <cyruntime.cudaMemcpy3DParms*>pNodeParams._ptr)
+    return (cudaError_t(err), pNodeParams)
 {{endif}}
 
-{{if 'cudaRuntimeGetVersion' in found_functions}}
+{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaRuntimeGetVersion():
-    """ Returns the CUDA Runtime version.
+def cudaGraphMemcpyNodeSetParams(node, pNodeParams : Optional[cudaMemcpy3DParms]):
+    """ Sets a memcpy node's parameters.
 
-    Returns in `*runtimeVersion` the version number of the current CUDA
-    Runtime instance. The version is returned as (1000 * major + 10 *
-    minor). For example, CUDA 9.2 would be represented by 9020.
+    Sets the parameters of memcpy node `node` to `pNodeParams`.
 
-    This function automatically returns :py:obj:`~.cudaErrorInvalidValue`
-    if the `runtimeVersion` argument is NULL.
+    Parameters
+    ----------
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the parameters for
+    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
+        Parameters to copy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    runtimeVersion : int
-        Returns the CUDA Runtime version.
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaDriverGetVersion`, :py:obj:`~.cuDriverGetVersion`
+    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphMemcpyNodeSetParamsToSymbol`, :py:obj:`~.cudaGraphMemcpyNodeSetParamsFromSymbol`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`
     """
-    cdef int runtimeVersion = 0
-    err = ccudart.cudaRuntimeGetVersion(&runtimeVersion)
-    return (cudaError_t(err), runtimeVersion)
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaMemcpy3DParms* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphMemcpyNodeSetParams(cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphCreate' in found_functions}}
+{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphCreate(unsigned int flags):
-    """ Creates a graph.
+def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None : cudaMemcpyKind):
+    """ Sets a memcpy node's parameters to perform a 1-dimensional copy.
 
-    Creates an empty graph, which is returned via `pGraph`.
+    Sets the parameters of memcpy node `node` to the copy described by the
+    provided parameters.
+
+    When the graph is launched, the node will copy `count` bytes from the
+    memory area pointed to by `src` to the memory area pointed to by `dst`,
+    where `kind` specifies the direction of the copy, and must be one of
+    :py:obj:`~.cudaMemcpyHostToHost`, :py:obj:`~.cudaMemcpyHostToDevice`,
+    :py:obj:`~.cudaMemcpyDeviceToHost`,
+    :py:obj:`~.cudaMemcpyDeviceToDevice`, or :py:obj:`~.cudaMemcpyDefault`.
+    Passing :py:obj:`~.cudaMemcpyDefault` is recommended, in which case the
+    type of transfer is inferred from the pointer values. However,
+    :py:obj:`~.cudaMemcpyDefault` is only allowed on systems that support
+    unified virtual addressing. Launching a memcpy node with dst and src
+    pointers that do not match the direction of the copy results in an
+    undefined behavior.
 
     Parameters
     ----------
-    flags : unsigned int
-        Graph creation flags, must be 0
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the parameters for
+    dst : Any
+        Destination memory address
+    src : Any
+        Source memory address
+    count : size_t
+        Size in bytes to copy
+    kind : :py:obj:`~.cudaMemcpyKind`
+        Type of transfer
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
-    pGraph : :py:obj:`~.cudaGraph_t`
-        Returns newly created graph
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphDestroy`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphClone`
+    :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`
     """
-    cdef cudaGraph_t pGraph = cudaGraph_t()
-    err = ccudart.cudaGraphCreate(<ccudart.cudaGraph_t*>pGraph._ptr, flags)
-    return (cudaError_t(err), pGraph)
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaGraphMemcpyNodeSetParams1D(cynode, cydst_ptr, cysrc_ptr, count, cykind)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddKernelNode' in found_functions}}
+{{if 'cudaGraphAddMemsetNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddKernelNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaKernelNodeParams]):
-    """ Creates a kernel execution node and adds it to a graph.
+def cudaGraphAddMemsetNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, pMemsetParams : Optional[cudaMemsetParams]):
+    """ Creates a memset node and adds it to a graph.
 
-    Creates a new kernel execution node and adds it to `graph` with
-    `numDependencies` dependencies specified via `pDependencies` and
-    arguments specified in `pNodeParams`. It is possible for
+    Creates a new memset node and adds it to `graph` with `numDependencies`
+    dependencies specified via `pDependencies`. It is possible for
     `numDependencies` to be 0, in which case the node will be placed at the
     root of the graph. `pDependencies` may not have any duplicate entries.
     A handle to the new node will be returned in `pGraphNode`.
 
-    The :py:obj:`~.cudaKernelNodeParams` structure is defined as:
-
-    **View CUDA Toolkit Documentation for a C++ code example**
-
-    When the graph is launched, the node will invoke kernel `func` on a
-    (`gridDim.x` x `gridDim.y` x `gridDim.z`) grid of blocks. Each block
-    contains (`blockDim.x` x `blockDim.y` x `blockDim.z`) threads.
-
-    `sharedMem` sets the amount of dynamic shared memory that will be
-    available to each thread block.
-
-    Kernel parameters to `func` can be specified in one of two ways:
-
-    1) Kernel parameters can be specified via `kernelParams`. If the kernel
-    has N parameters, then `kernelParams` needs to be an array of N
-    pointers. Each pointer, from `kernelParams`[0] to `kernelParams`[N-1],
-    points to the region of memory from which the actual parameter will be
-    copied. The number of kernel parameters and their offsets and sizes do
-    not need to be specified as that information is retrieved directly from
-    the kernel's image.
-
-    2) Kernel parameters can also be packaged by the application into a
-    single buffer that is passed in via `extra`. This places the burden on
-    the application of knowing each kernel parameter's size and
-    alignment/padding within the buffer. The `extra` parameter exists to
-    allow this function to take additional less commonly used arguments.
-    `extra` specifies a list of names of extra settings and their
-    corresponding values. Each extra setting name is immediately followed
-    by the corresponding value. The list must be terminated with either
-    NULL or CU_LAUNCH_PARAM_END.
-
-    - :py:obj:`~.CU_LAUNCH_PARAM_END`, which indicates the end of the
-      `extra` array;
-
-    - :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER`, which specifies that the
-      next value in `extra` will be a pointer to a buffer containing all
-      the kernel parameters for launching kernel `func`;
-
-    - :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE`, which specifies that the
-      next value in `extra` will be a pointer to a size_t containing the
-      size of the buffer specified with
-      :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER`;
-
-    The error :py:obj:`~.cudaErrorInvalidValue` will be returned if kernel
-    parameters are specified with both `kernelParams` and `extra` (i.e.
-    both `kernelParams` and `extra` are non-NULL).
-
-    The `kernelParams` or `extra` array, as well as the argument values it
-    points to, are copied during this call.
+    The element size must be 1, 2, or 4 bytes. When the graph is launched,
+    the node will perform the memset described by `pMemsetParams`.
 
     Parameters
     ----------
@@ -21523,72 +21943,56 @@ def cudaGraphAddKernelNode(graph, pDependencies : Optional[List[cudaGraphNode_t]
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
-        Parameters for the GPU execution node
+    pMemsetParams : :py:obj:`~.cudaMemsetParams`
+        Parameters for the memory set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDeviceFunction`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
     pGraphNode : :py:obj:`~.cudaGraphNode_t`
         Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphKernelNodeGetParams`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
-
-    Notes
-    -----
-    Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
+    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphMemsetNodeGetParams`, :py:obj:`~.cudaGraphMemsetNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`
     """
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaKernelNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphAddKernelNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cpNodeParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    cdef cyruntime.cudaMemsetParams* cypMemsetParams_ptr = pMemsetParams._ptr if pMemsetParams != None else NULL
+    err = cyruntime.cudaGraphAddMemsetNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypMemsetParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphKernelNodeGetParams' in found_functions}}
+{{if 'cudaGraphMemsetNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphKernelNodeGetParams(node):
-    """ Returns a kernel node's parameters.
-
-    Returns the parameters of kernel node `node` in `pNodeParams`. The
-    `kernelParams` or `extra` array returned in `pNodeParams`, as well as
-    the argument values it points to, are owned by the node. This memory
-    remains valid until the node is destroyed or its parameters are
-    modified, and should not be modified directly. Use
-    :py:obj:`~.cudaGraphKernelNodeSetParams` to update the parameters of
-    this node.
+def cudaGraphMemsetNodeGetParams(node):
+    """ Returns a memset node's parameters.
 
-    The params will contain either `kernelParams` or `extra`, according to
-    which of these was most recently set on the node.
+    Returns the parameters of memset node `node` in `pNodeParams`.
 
     Parameters
     ----------
@@ -21598,224 +22002,227 @@ def cudaGraphKernelNodeGetParams(node):
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDeviceFunction`
-    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pNodeParams : :py:obj:`~.cudaMemsetParams`
         Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeSetParams`
+    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeSetParams`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaKernelNodeParams pNodeParams = cudaKernelNodeParams()
-    err = ccudart.cudaGraphKernelNodeGetParams(cnode, pNodeParams._ptr)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaMemsetParams pNodeParams = cudaMemsetParams()
+    err = cyruntime.cudaGraphMemsetNodeGetParams(cynode, <cyruntime.cudaMemsetParams*>pNodeParams._ptr)
     return (cudaError_t(err), pNodeParams)
 {{endif}}
 
-{{if 'cudaGraphKernelNodeSetParams' in found_functions}}
+{{if 'cudaGraphMemsetNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphKernelNodeSetParams(node, pNodeParams : Optional[cudaKernelNodeParams]):
-    """ Sets a kernel node's parameters.
+def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams]):
+    """ Sets a memset node's parameters.
 
-    Sets the parameters of kernel node `node` to `pNodeParams`.
+    Sets the parameters of memset node `node` to `pNodeParams`.
 
     Parameters
     ----------
     node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
         Node to set the parameters for
-    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+    pNodeParams : :py:obj:`~.cudaMemsetParams`
         Parameters to copy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorMemoryAllocation`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeGetParams`
+    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeGetParams`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaKernelNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphKernelNodeSetParams(cnode, cpNodeParams_ptr)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaMemsetParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphMemsetNodeSetParams(cynode, cypNodeParams_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphKernelNodeCopyAttributes' in found_functions}}
+{{if 'cudaGraphAddHostNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphKernelNodeCopyAttributes(hSrc, hDst):
-    """ Copies attributes from source node to destination node.
+def cudaGraphAddHostNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaHostNodeParams]):
+    """ Creates a host execution node and adds it to a graph.
 
-    Copies attributes from source node `src` to destination node `dst`.
-    Both node must have the same context.
+    Creates a new CPU execution node and adds it to `graph` with
+    `numDependencies` dependencies specified via `pDependencies` and
+    arguments specified in `pNodeParams`. It is possible for
+    `numDependencies` to be 0, in which case the node will be placed at the
+    root of the graph. `pDependencies` may not have any duplicate entries.
+    A handle to the new node will be returned in `pGraphNode`.
+
+    When the graph is launched, the node will invoke the specified CPU
+    function. Host nodes are not supported under MPS with pre-Volta GPUs.
 
     Parameters
     ----------
-    dst : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Destination node
-    src : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Source node For list of attributes see
-        :py:obj:`~.cudaKernelNodeAttrID`
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which to add the node
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Dependencies of the node
+    numDependencies : size_t
+        Number of dependencies
+    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+        Parameters for the host node
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidContext`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
+        Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaAccessPolicyWindow`
+    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphHostNodeGetParams`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaGraphNode_t chDst
-    if hDst is None:
-        chDst = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hDst, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phDst = int(hDst)
-        chDst = <ccudart.cudaGraphNode_t><void_ptr>phDst
-    else:
-        phDst = int(cudaGraphNode_t(hDst))
-        chDst = <ccudart.cudaGraphNode_t><void_ptr>phDst
-
-    cdef ccudart.cudaGraphNode_t chSrc
-    if hSrc is None:
-        chSrc = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hSrc, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phSrc = int(hSrc)
-        chSrc = <ccudart.cudaGraphNode_t><void_ptr>phSrc
+    pDependencies = [] if pDependencies is None else pDependencies
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phSrc = int(cudaGraphNode_t(hSrc))
-        chSrc = <ccudart.cudaGraphNode_t><void_ptr>phSrc
-
-    err = ccudart.cudaGraphKernelNodeCopyAttributes(chSrc, chDst)
-    return (cudaError_t(err),)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    if len(pDependencies) > 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(pDependencies)):
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
+    cdef cyruntime.cudaHostNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphAddHostNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cypNodeParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphKernelNodeGetAttribute' in found_functions}}
+{{if 'cudaGraphHostNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphKernelNodeGetAttribute(hNode, attr not None : cudaKernelNodeAttrID):
-    """ Queries node attribute.
+def cudaGraphHostNodeGetParams(node):
+    """ Returns a host node's parameters.
 
-    Queries attribute `attr` from node `hNode` and stores it in
-    corresponding member of `value_out`.
+    Returns the parameters of host node `node` in `pNodeParams`.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-
-    attr : :py:obj:`~.cudaKernelNodeAttrID`
-
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`
-    value_out : :py:obj:`~.cudaKernelNodeAttrValue`
-
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+        Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaAccessPolicyWindow`
+    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeSetParams`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaKernelNodeAttrID cattr = attr.value
-    cdef cudaLaunchAttributeValue value_out = cudaLaunchAttributeValue()
-    err = ccudart.cudaGraphKernelNodeGetAttribute(chNode, cattr, value_out._ptr)
-    return (cudaError_t(err), value_out)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaHostNodeParams pNodeParams = cudaHostNodeParams()
+    err = cyruntime.cudaGraphHostNodeGetParams(cynode, <cyruntime.cudaHostNodeParams*>pNodeParams._ptr)
+    return (cudaError_t(err), pNodeParams)
 {{endif}}
 
-{{if 'cudaGraphKernelNodeSetAttribute' in found_functions}}
+{{if 'cudaGraphHostNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphKernelNodeSetAttribute(hNode, attr not None : cudaKernelNodeAttrID, value : Optional[cudaLaunchAttributeValue]):
-    """ Sets node attribute.
+def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams]):
+    """ Sets a host node's parameters.
 
-    Sets attribute `attr` on node `hNode` from corresponding attribute of
-    `value`.
+    Sets the parameters of host node `node` to `nodeParams`.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-
-    attr : :py:obj:`~.cudaKernelNodeAttrID`
-
-    value : :py:obj:`~.cudaKernelNodeAttrValue`
-
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the parameters for
+    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+        Parameters to copy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaAccessPolicyWindow`
+    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeGetParams`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaKernelNodeAttrID cattr = attr.value
-    cdef ccudart.cudaKernelNodeAttrValue* cvalue_ptr = value._ptr if value != None else NULL
-    err = ccudart.cudaGraphKernelNodeSetAttribute(chNode, cattr, cvalue_ptr)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaHostNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphHostNodeSetParams(cynode, cypNodeParams_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddMemcpyNode' in found_functions}}
+{{if 'cudaGraphAddChildGraphNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, pCopyParams : Optional[cudaMemcpy3DParms]):
-    """ Creates a memcpy node and adds it to a graph.
+def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, childGraph):
+    """ Creates a child graph node and adds it to a graph.
 
-    Creates a new memcpy node and adds it to `graph` with `numDependencies`
-    dependencies specified via `pDependencies`. It is possible for
-    `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `pDependencies` may not have any duplicate entries.
-    A handle to the new node will be returned in `pGraphNode`.
+    Creates a new node which executes an embedded graph, and adds it to
+    `graph` with `numDependencies` dependencies specified via
+    `pDependencies`. It is possible for `numDependencies` to be 0, in which
+    case the node will be placed at the root of the graph. `pDependencies`
+    may not have any duplicate entries. A handle to the new node will be
+    returned in `pGraphNode`.
 
-    When the graph is launched, the node will perform the memcpy described
-    by `pCopyParams`. See :py:obj:`~.cudaMemcpy3D()` for a description of
-    the structure and its restrictions.
+    If `hGraph` contains allocation or free nodes, this call will return an
+    error.
 
-    Memcpy nodes have some additional restrictions with regards to managed
-    memory, if the system contains at least one device which has a zero
-    value for the device attribute
-    :py:obj:`~.cudaDevAttrConcurrentManagedAccess`.
+    The node executes an embedded child graph. The child graph is cloned in
+    this call.
 
     Parameters
     ----------
@@ -21825,8 +22232,8 @@ def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[List[cudaGraphNode_t]
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    pCopyParams : :py:obj:`~.cudaMemcpy3DParms`
-        Parameters for the memory copy
+    childGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph to clone into this node
 
     Returns
     -------
@@ -21837,70 +22244,106 @@ def cudaGraphAddMemcpyNode(graph, pDependencies : Optional[List[cudaGraphNode_t]
 
     See Also
     --------
-    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphAddMemcpyNodeToSymbol`, :py:obj:`~.cudaGraphAddMemcpyNodeFromSymbol`, :py:obj:`~.cudaGraphAddMemcpyNode1D`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphClone`
     """
+    cdef cyruntime.cudaGraph_t cychildGraph
+    if childGraph is None:
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(childGraph, (cudaGraph_t,driver.CUgraph)):
+        pchildGraph = int(childGraph)
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>pchildGraph
+    else:
+        pchildGraph = int(cudaGraph_t(childGraph))
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>pchildGraph
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaMemcpy3DParms* cpCopyParams_ptr = pCopyParams._ptr if pCopyParams != None else NULL
-    err = ccudart.cudaGraphAddMemcpyNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cpCopyParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    err = cyruntime.cudaGraphAddChildGraphNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cychildGraph)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphAddMemcpyNode1D' in found_functions}}
+{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, dst, src, size_t count, kind not None : cudaMemcpyKind):
-    """ Creates a 1D memcpy node and adds it to a graph.
+def cudaGraphChildGraphNodeGetGraph(node):
+    """ Gets a handle to the embedded graph of a child graph node.
 
-    Creates a new 1D memcpy node and adds it to `graph` with
-    `numDependencies` dependencies specified via `pDependencies`. It is
-    possible for `numDependencies` to be 0, in which case the node will be
-    placed at the root of the graph. `pDependencies` may not have any
+    Gets a handle to the embedded graph in a child graph node. This call
+    does not clone the graph. Changes to the graph will be reflected in the
+    node, and the node retains ownership of the graph.
+
+    Allocation and free nodes cannot be added to the returned graph.
+    Attempting to do so will return an error.
+
+    Parameters
+    ----------
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the embedded graph for
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pGraph : :py:obj:`~.cudaGraph_t`
+        Location to store a handle to the graph
+
+    See Also
+    --------
+    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphNodeFindInClone`
+    """
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaGraph_t pGraph = cudaGraph_t()
+    err = cyruntime.cudaGraphChildGraphNodeGetGraph(cynode, <cyruntime.cudaGraph_t*>pGraph._ptr)
+    return (cudaError_t(err), pGraph)
+{{endif}}
+
+{{if 'cudaGraphAddEmptyNode' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGraphAddEmptyNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies):
+    """ Creates an empty node and adds it to a graph.
+
+    Creates a new node which performs no operation, and adds it to `graph`
+    with `numDependencies` dependencies specified via `pDependencies`. It
+    is possible for `numDependencies` to be 0, in which case the node will
+    be placed at the root of the graph. `pDependencies` may not have any
     duplicate entries. A handle to the new node will be returned in
     `pGraphNode`.
 
-    When the graph is launched, the node will copy `count` bytes from the
-    memory area pointed to by `src` to the memory area pointed to by `dst`,
-    where `kind` specifies the direction of the copy, and must be one of
-    :py:obj:`~.cudaMemcpyHostToHost`, :py:obj:`~.cudaMemcpyHostToDevice`,
-    :py:obj:`~.cudaMemcpyDeviceToHost`,
-    :py:obj:`~.cudaMemcpyDeviceToDevice`, or :py:obj:`~.cudaMemcpyDefault`.
-    Passing :py:obj:`~.cudaMemcpyDefault` is recommended, in which case the
-    type of transfer is inferred from the pointer values. However,
-    :py:obj:`~.cudaMemcpyDefault` is only allowed on systems that support
-    unified virtual addressing. Launching a memcpy node with dst and src
-    pointers that do not match the direction of the copy results in an
-    undefined behavior.
-
-    Memcpy nodes have some additional restrictions with regards to managed
-    memory, if the system contains at least one device which has a zero
-    value for the device attribute
-    :py:obj:`~.cudaDevAttrConcurrentManagedAccess`.
+    An empty node performs no operation during execution, but can be used
+    for transitive ordering. For example, a phased execution graph with 2
+    groups of n nodes with a barrier between them can be represented using
+    an empty node and 2*n dependency edges, rather than no empty node and
+    n^2 dependency edges.
 
     Parameters
     ----------
@@ -21910,14 +22353,6 @@ def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[List[cudaGraphNode_
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    dst : Any
-        Destination memory address
-    src : Any
-        Source memory address
-    count : size_t
-        Size in bytes to copy
-    kind : :py:obj:`~.cudaMemcpyKind`
-        Type of transfer
 
     Returns
     -------
@@ -21928,155 +22363,165 @@ def cudaGraphAddMemcpyNode1D(graph, pDependencies : Optional[List[cudaGraphNode_
 
     See Also
     --------
-    :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaGraphAddMemcpyNode1D(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cdst_ptr, csrc_ptr, count, ckind)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
+    err = cyruntime.cudaGraphAddEmptyNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphMemcpyNodeGetParams' in found_functions}}
+{{if 'cudaGraphAddEventRecordNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemcpyNodeGetParams(node):
-    """ Returns a memcpy node's parameters.
+def cudaGraphAddEventRecordNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, event):
+    """ Creates an event record node and adds it to a graph.
 
-    Returns the parameters of memcpy node `node` in `pNodeParams`.
+    Creates a new event record node and adds it to `hGraph` with
+    `numDependencies` dependencies specified via `dependencies` and event
+    specified in `event`. It is possible for `numDependencies` to be 0, in
+    which case the node will be placed at the root of the graph.
+    `dependencies` may not have any duplicate entries. A handle to the new
+    node will be returned in `phGraphNode`.
+
+    Each launch of the graph will record `event` to capture execution of
+    the node's dependencies.
+
+    These nodes may not be used in loops or conditionals.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which to add the node
+    dependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Dependencies of the node
+    numDependencies : size_t
+        Number of dependencies
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Event for the node
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
-        Pointer to return the parameters
+    phGraphNode : :py:obj:`~.cudaGraphNode_t`
+        Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`
+    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaMemcpy3DParms pNodeParams = cudaMemcpy3DParms()
-    err = ccudart.cudaGraphMemcpyNodeGetParams(cnode, pNodeParams._ptr)
-    return (cudaError_t(err), pNodeParams)
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    pDependencies = [] if pDependencies is None else pDependencies
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    else:
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    if len(pDependencies) > 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(pDependencies)):
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
+    err = cyruntime.cudaGraphAddEventRecordNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cyevent)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphMemcpyNodeSetParams' in found_functions}}
+{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemcpyNodeSetParams(node, pNodeParams : Optional[cudaMemcpy3DParms]):
-    """ Sets a memcpy node's parameters.
+def cudaGraphEventRecordNodeGetEvent(node):
+    """ Returns the event associated with an event record node.
 
-    Sets the parameters of memcpy node `node` to `pNodeParams`.
+    Returns the event of event record node `hNode` in `event_out`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the parameters for
-    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
-        Parameters to copy
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the event for
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    event_out : :py:obj:`~.cudaEvent_t`
+        Pointer to return the event
 
     See Also
     --------
-    :py:obj:`~.cudaMemcpy3D`, :py:obj:`~.cudaGraphMemcpyNodeSetParamsToSymbol`, :py:obj:`~.cudaGraphMemcpyNodeSetParamsFromSymbol`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`
+    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaMemcpy3DParms* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphMemcpyNodeSetParams(cnode, cpNodeParams_ptr)
-    return (cudaError_t(err),)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaEvent_t event_out = cudaEvent_t()
+    err = cyruntime.cudaGraphEventRecordNodeGetEvent(cynode, <cyruntime.cudaEvent_t*>event_out._ptr)
+    return (cudaError_t(err), event_out)
 {{endif}}
 
-{{if 'cudaGraphMemcpyNodeSetParams1D' in found_functions}}
+{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None : cudaMemcpyKind):
-    """ Sets a memcpy node's parameters to perform a 1-dimensional copy.
-
-    Sets the parameters of memcpy node `node` to the copy described by the
-    provided parameters.
+def cudaGraphEventRecordNodeSetEvent(node, event):
+    """ Sets an event record node's event.
 
-    When the graph is launched, the node will copy `count` bytes from the
-    memory area pointed to by `src` to the memory area pointed to by `dst`,
-    where `kind` specifies the direction of the copy, and must be one of
-    :py:obj:`~.cudaMemcpyHostToHost`, :py:obj:`~.cudaMemcpyHostToDevice`,
-    :py:obj:`~.cudaMemcpyDeviceToHost`,
-    :py:obj:`~.cudaMemcpyDeviceToDevice`, or :py:obj:`~.cudaMemcpyDefault`.
-    Passing :py:obj:`~.cudaMemcpyDefault` is recommended, in which case the
-    type of transfer is inferred from the pointer values. However,
-    :py:obj:`~.cudaMemcpyDefault` is only allowed on systems that support
-    unified virtual addressing. Launching a memcpy node with dst and src
-    pointers that do not match the direction of the copy results in an
-    undefined behavior.
+    Sets the event of event record node `hNode` to `event`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the parameters for
-    dst : Any
-        Destination memory address
-    src : Any
-        Source memory address
-    count : size_t
-        Size in bytes to copy
-    kind : :py:obj:`~.cudaMemcpyKind`
-        Type of transfer
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the event for
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Event to use
 
     Returns
     -------
@@ -22085,149 +22530,162 @@ def cudaGraphMemcpyNodeSetParams1D(node, dst, src, size_t count, kind not None :
 
     See Also
     --------
-    :py:obj:`~.cudaMemcpy`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`
+    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    else:
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaGraphMemcpyNodeSetParams1D(cnode, cdst_ptr, csrc_ptr, count, ckind)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    err = cyruntime.cudaGraphEventRecordNodeSetEvent(cynode, cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddMemsetNode' in found_functions}}
+{{if 'cudaGraphAddEventWaitNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddMemsetNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, pMemsetParams : Optional[cudaMemsetParams]):
-    """ Creates a memset node and adds it to a graph.
+def cudaGraphAddEventWaitNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, event):
+    """ Creates an event wait node and adds it to a graph.
 
-    Creates a new memset node and adds it to `graph` with `numDependencies`
-    dependencies specified via `pDependencies`. It is possible for
-    `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `pDependencies` may not have any duplicate entries.
-    A handle to the new node will be returned in `pGraphNode`.
+    Creates a new event wait node and adds it to `hGraph` with
+    `numDependencies` dependencies specified via `dependencies` and event
+    specified in `event`. It is possible for `numDependencies` to be 0, in
+    which case the node will be placed at the root of the graph.
+    `dependencies` may not have any duplicate entries. A handle to the new
+    node will be returned in `phGraphNode`.
 
-    The element size must be 1, 2, or 4 bytes. When the graph is launched,
-    the node will perform the memset described by `pMemsetParams`.
+    The graph node will wait for all work captured in `event`. See
+    :py:obj:`~.cuEventRecord()` for details on what is captured by an
+    event. The synchronization will be performed efficiently on the device
+    when applicable. `event` may be from a different context or device than
+    the launch stream.
+
+    These nodes may not be used in loops or conditionals.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
         Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+    dependencies : List[:py:obj:`~.cudaGraphNode_t`]
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    pMemsetParams : :py:obj:`~.cudaMemsetParams`
-        Parameters for the memory set
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Event for the node
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidDevice`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    phGraphNode : :py:obj:`~.cudaGraphNode_t`
         Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphMemsetNodeGetParams`, :py:obj:`~.cudaGraphMemsetNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`
+    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
     """
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    else:
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaMemsetParams* cpMemsetParams_ptr = pMemsetParams._ptr if pMemsetParams != None else NULL
-    err = ccudart.cudaGraphAddMemsetNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cpMemsetParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    err = cyruntime.cudaGraphAddEventWaitNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cyevent)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphMemsetNodeGetParams' in found_functions}}
+{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemsetNodeGetParams(node):
-    """ Returns a memset node's parameters.
+def cudaGraphEventWaitNodeGetEvent(node):
+    """ Returns the event associated with an event wait node.
 
-    Returns the parameters of memset node `node` in `pNodeParams`.
+    Returns the event of event wait node `hNode` in `event_out`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the event for
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pNodeParams : :py:obj:`~.cudaMemsetParams`
-        Pointer to return the parameters
+    event_out : :py:obj:`~.cudaEvent_t`
+        Pointer to return the event
 
     See Also
     --------
-    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeSetParams`
+    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaMemsetParams pNodeParams = cudaMemsetParams()
-    err = ccudart.cudaGraphMemsetNodeGetParams(cnode, pNodeParams._ptr)
-    return (cudaError_t(err), pNodeParams)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaEvent_t event_out = cudaEvent_t()
+    err = cyruntime.cudaGraphEventWaitNodeGetEvent(cynode, <cyruntime.cudaEvent_t*>event_out._ptr)
+    return (cudaError_t(err), event_out)
 {{endif}}
 
-{{if 'cudaGraphMemsetNodeSetParams' in found_functions}}
+{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams]):
-    """ Sets a memset node's parameters.
+def cudaGraphEventWaitNodeSetEvent(node, event):
+    """ Sets an event wait node's event.
 
-    Sets the parameters of memset node `node` to `pNodeParams`.
+    Sets the event of event wait node `hNode` to `event`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the parameters for
-    pNodeParams : :py:obj:`~.cudaMemsetParams`
-        Parameters to copy
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the event for
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Event to use
 
     Returns
     -------
@@ -22236,38 +22694,46 @@ def cudaGraphMemsetNodeSetParams(node, pNodeParams : Optional[cudaMemsetParams])
 
     See Also
     --------
-    :py:obj:`~.cudaMemset2D`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeGetParams`
+    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    else:
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaMemsetParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphMemsetNodeSetParams(cnode, cpNodeParams_ptr)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    err = cyruntime.cudaGraphEventWaitNodeSetEvent(cynode, cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddHostNode' in found_functions}}
+{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddHostNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, pNodeParams : Optional[cudaHostNodeParams]):
-    """ Creates a host execution node and adds it to a graph.
+def cudaGraphAddExternalSemaphoresSignalNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
+    """ Creates an external semaphore signal node and adds it to a graph.
 
-    Creates a new CPU execution node and adds it to `graph` with
-    `numDependencies` dependencies specified via `pDependencies` and
-    arguments specified in `pNodeParams`. It is possible for
+    Creates a new external semaphore signal node and adds it to `graph`
+    with `numDependencies` dependencies specified via `dependencies` and
+    arguments specified in `nodeParams`. It is possible for
     `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `pDependencies` may not have any duplicate entries.
-    A handle to the new node will be returned in `pGraphNode`.
+    root of the graph. `dependencies` may not have any duplicate entries. A
+    handle to the new node will be returned in `pGraphNode`.
 
-    When the graph is launched, the node will invoke the specified CPU
-    function. Host nodes are not supported under MPS with pre-Volta GPUs.
+    Performs a signal operation on a set of externally allocated semaphore
+    objects when the node is launched. The operation(s) will occur after
+    all of the node's dependencies have completed.
 
     Parameters
     ----------
@@ -22277,104 +22743,107 @@ def cudaGraphAddHostNode(graph, pDependencies : Optional[List[cudaGraphNode_t]],
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    pNodeParams : :py:obj:`~.cudaHostNodeParams`
-        Parameters for the host node
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
+        Parameters for the node
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
     pGraphNode : :py:obj:`~.cudaGraphNode_t`
         Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphHostNodeGetParams`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeGetParams`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
     """
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaHostNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphAddHostNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cpNodeParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphAddExternalSemaphoresSignalNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphHostNodeGetParams' in found_functions}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphHostNodeGetParams(node):
-    """ Returns a host node's parameters.
+def cudaGraphExternalSemaphoresSignalNodeGetParams(hNode):
+    """ Returns an external semaphore signal node's parameters.
 
-    Returns the parameters of host node `node` in `pNodeParams`.
+    Returns the parameters of an external semaphore signal node `hNode` in
+    `params_out`. The `extSemArray` and `paramsArray` returned in
+    `params_out`, are owned by the node. This memory remains valid until
+    the node is destroyed or its parameters are modified, and should not be
+    modified directly. Use
+    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams` to update
+    the parameters of this node.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
         Node to get the parameters for
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+    params_out : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
         Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeSetParams`
+    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaHostNodeParams pNodeParams = cudaHostNodeParams()
-    err = ccudart.cudaGraphHostNodeGetParams(cnode, pNodeParams._ptr)
-    return (cudaError_t(err), pNodeParams)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cudaExternalSemaphoreSignalNodeParams params_out = cudaExternalSemaphoreSignalNodeParams()
+    err = cyruntime.cudaGraphExternalSemaphoresSignalNodeGetParams(cyhNode, <cyruntime.cudaExternalSemaphoreSignalNodeParams*>params_out._ptr)
+    return (cudaError_t(err), params_out)
 {{endif}}
 
-{{if 'cudaGraphHostNodeSetParams' in found_functions}}
+{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams]):
-    """ Sets a host node's parameters.
+def cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
+    """ Sets an external semaphore signal node's parameters.
 
-    Sets the parameters of host node `node` to `nodeParams`.
+    Sets the parameters of an external semaphore signal node `hNode` to
+    `nodeParams`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
         Node to set the parameters for
-    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
         Parameters to copy
 
     Returns
@@ -22384,41 +22853,38 @@ def cudaGraphHostNodeSetParams(node, pNodeParams : Optional[cudaHostNodeParams])
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchHostFunc`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeGetParams`
+    :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaHostNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphHostNodeSetParams(cnode, cpNodeParams_ptr)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphExternalSemaphoresSignalNodeSetParams(cyhNode, cynodeParams_ptr)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddChildGraphNode' in found_functions}}
+{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, childGraph):
-    """ Creates a child graph node and adds it to a graph.
-
-    Creates a new node which executes an embedded graph, and adds it to
-    `graph` with `numDependencies` dependencies specified via
-    `pDependencies`. It is possible for `numDependencies` to be 0, in which
-    case the node will be placed at the root of the graph. `pDependencies`
-    may not have any duplicate entries. A handle to the new node will be
-    returned in `pGraphNode`.
+def cudaGraphAddExternalSemaphoresWaitNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
+    """ Creates an external semaphore wait node and adds it to a graph.
 
-    If `hGraph` contains allocation or free nodes, this call will return an
-    error.
+    Creates a new external semaphore wait node and adds it to `graph` with
+    `numDependencies` dependencies specified via `dependencies` and
+    arguments specified in `nodeParams`. It is possible for
+    `numDependencies` to be 0, in which case the node will be placed at the
+    root of the graph. `dependencies` may not have any duplicate entries. A
+    handle to the new node will be returned in `pGraphNode`.
 
-    The node executes an embedded child graph. The child graph is cloned in
-    this call.
+    Performs a wait operation on a set of externally allocated semaphore
+    objects when the node is launched. The node's dependencies will not be
+    launched until the wait operation has completed.
 
     Parameters
     ----------
@@ -22428,8 +22894,8 @@ def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[List[cudaGraphNod
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    childGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph to clone into this node
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
+        Parameters for the node
 
     Returns
     -------
@@ -22440,468 +22906,405 @@ def cudaGraphAddChildGraphNode(graph, pDependencies : Optional[List[cudaGraphNod
 
     See Also
     --------
-    :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphClone`
+    :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeGetParams`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
     """
-    cdef ccudart.cudaGraph_t cchildGraph
-    if childGraph is None:
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(childGraph, (cudaGraph_t,cuda.CUgraph)):
-        pchildGraph = int(childGraph)
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>pchildGraph
-    else:
-        pchildGraph = int(cudaGraph_t(childGraph))
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>pchildGraph
-
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphAddChildGraphNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cchildGraph)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphAddExternalSemaphoresWaitNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphChildGraphNodeGetGraph' in found_functions}}
+{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphChildGraphNodeGetGraph(node):
-    """ Gets a handle to the embedded graph of a child graph node.
+def cudaGraphExternalSemaphoresWaitNodeGetParams(hNode):
+    """ Returns an external semaphore wait node's parameters.
 
-    Gets a handle to the embedded graph in a child graph node. This call
-    does not clone the graph. Changes to the graph will be reflected in the
-    node, and the node retains ownership of the graph.
+    Returns the parameters of an external semaphore wait node `hNode` in
+    `params_out`. The `extSemArray` and `paramsArray` returned in
+    `params_out`, are owned by the node. This memory remains valid until
+    the node is destroyed or its parameters are modified, and should not be
+    modified directly. Use
+    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams` to update
+    the parameters of this node.
 
-    Allocation and free nodes cannot be added to the returned graph.
-    Attempting to do so will return an error.
+    Parameters
+    ----------
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    params_out : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
+        Pointer to return the parameters
+
+    See Also
+    --------
+    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
+    """
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    else:
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cudaExternalSemaphoreWaitNodeParams params_out = cudaExternalSemaphoreWaitNodeParams()
+    err = cyruntime.cudaGraphExternalSemaphoresWaitNodeGetParams(cyhNode, <cyruntime.cudaExternalSemaphoreWaitNodeParams*>params_out._ptr)
+    return (cudaError_t(err), params_out)
+{{endif}}
+
+{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
+    """ Sets an external semaphore wait node's parameters.
+
+    Sets the parameters of an external semaphore wait node `hNode` to
+    `nodeParams`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the embedded graph for
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to set the parameters for
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
+        Parameters to copy
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraph : :py:obj:`~.cudaGraph_t`
-        Location to store a handle to the graph
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphNodeFindInClone`
+    :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaGraph_t pGraph = cudaGraph_t()
-    err = ccudart.cudaGraphChildGraphNodeGetGraph(cnode, <ccudart.cudaGraph_t*>pGraph._ptr)
-    return (cudaError_t(err), pGraph)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphExternalSemaphoresWaitNodeSetParams(cyhNode, cynodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddEmptyNode' in found_functions}}
+{{if 'cudaGraphAddMemAllocNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddEmptyNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies):
-    """ Creates an empty node and adds it to a graph.
+def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaMemAllocNodeParams]):
+    """ Creates an allocation node and adds it to a graph.
 
-    Creates a new node which performs no operation, and adds it to `graph`
-    with `numDependencies` dependencies specified via `pDependencies`. It
-    is possible for `numDependencies` to be 0, in which case the node will
-    be placed at the root of the graph. `pDependencies` may not have any
-    duplicate entries. A handle to the new node will be returned in
-    `pGraphNode`.
+    Creates a new allocation node and adds it to `graph` with
+    `numDependencies` dependencies specified via `pDependencies` and
+    arguments specified in `nodeParams`. It is possible for
+    `numDependencies` to be 0, in which case the node will be placed at the
+    root of the graph. `pDependencies` may not have any duplicate entries.
+    A handle to the new node will be returned in `pGraphNode`.
 
-    An empty node performs no operation during execution, but can be used
-    for transitive ordering. For example, a phased execution graph with 2
-    groups of n nodes with a barrier between them can be represented using
-    an empty node and 2*n dependency edges, rather than no empty node and
-    n^2 dependency edges.
+    When :py:obj:`~.cudaGraphAddMemAllocNode` creates an allocation node,
+    it returns the address of the allocation in `nodeParams.dptr`. The
+    allocation's address remains fixed across instantiations and launches.
 
-    Parameters
-    ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Dependencies of the node
-    numDependencies : size_t
-        Number of dependencies
+    If the allocation is freed in the same graph, by creating a free node
+    using :py:obj:`~.cudaGraphAddMemFreeNode`, the allocation can be
+    accessed by nodes ordered after the allocation node but before the free
+    node. These allocations cannot be freed outside the owning graph, and
+    they can only be freed once in the owning graph.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
-        Returns newly created node
+    If the allocation is not freed in the same graph, then it can be
+    accessed not only by nodes in the graph which are ordered after the
+    allocation node, but also by stream operations ordered after the
+    graph's execution but before the allocation is freed.
 
-    See Also
-    --------
-    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
-    """
-    pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
+    Allocations which are not freed in the same graph can be freed by:
 
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-    else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    - passing the allocation to :py:obj:`~.cudaMemFreeAsync` or
+      :py:obj:`~.cudaMemFree`;
 
-    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
+    - launching a graph with a free node for that allocation; or
 
-    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphAddEmptyNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pGraphNode)
-{{endif}}
+    - specifying :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`
+      during instantiation, which makes each launch behave as though it
+      called :py:obj:`~.cudaMemFreeAsync` for every unfreed allocation.
 
-{{if 'cudaGraphAddEventRecordNode' in found_functions}}
+    It is not possible to free an allocation in both the owning graph and
+    another graph. If the allocation is freed in the same graph, a free
+    node cannot be added to another graph. If the allocation is freed in
+    another graph, a free node can no longer be added to the owning graph.
 
-@cython.embedsignature(True)
-def cudaGraphAddEventRecordNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, event):
-    """ Creates an event record node and adds it to a graph.
+    The following restrictions apply to graphs which contain allocation
+    and/or memory free nodes:
 
-    Creates a new event record node and adds it to `hGraph` with
-    `numDependencies` dependencies specified via `dependencies` and event
-    specified in `event`. It is possible for `numDependencies` to be 0, in
-    which case the node will be placed at the root of the graph.
-    `dependencies` may not have any duplicate entries. A handle to the new
-    node will be returned in `phGraphNode`.
+    - Nodes and edges of the graph cannot be deleted.
 
-    Each launch of the graph will record `event` to capture execution of
-    the node's dependencies.
+    - The graph cannot be used in a child node.
 
-    These nodes may not be used in loops or conditionals.
+    - Only one instantiation of the graph may exist at any point in time.
+
+    - The graph cannot be cloned.
 
     Parameters
     ----------
-    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
         Graph to which to add the node
-    dependencies : List[:py:obj:`~.cudaGraphNode_t`]
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Event for the node
+    nodeParams : :py:obj:`~.cudaMemAllocNodeParams`
+        Parameters for the node
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    phGraphNode : :py:obj:`~.cudaGraphNode_t`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorCudartUnloading`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOutOfMemory`
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
         Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
+    :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaGraphMemAllocNodeGetParams`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphAddEventRecordNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cevent)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    cdef cyruntime.cudaMemAllocNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphAddMemAllocNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cynodeParams_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphEventRecordNodeGetEvent' in found_functions}}
+{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphEventRecordNodeGetEvent(node):
-    """ Returns the event associated with an event record node.
+def cudaGraphMemAllocNodeGetParams(node):
+    """ Returns a memory alloc node's parameters.
 
-    Returns the event of event record node `hNode` in `event_out`.
+    Returns the parameters of a memory alloc node `hNode` in `params_out`.
+    The `poolProps` and `accessDescs` returned in `params_out`, are owned
+    by the node. This memory remains valid until the node is destroyed. The
+    returned parameters must not be modified.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the event for
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    event_out : :py:obj:`~.cudaEvent_t`
-        Pointer to return the event
+    params_out : :py:obj:`~.cudaMemAllocNodeParams`
+        Pointer to return the parameters
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
+    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaEvent_t event_out = cudaEvent_t()
-    err = ccudart.cudaGraphEventRecordNodeGetEvent(cnode, <ccudart.cudaEvent_t*>event_out._ptr)
-    return (cudaError_t(err), event_out)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cudaMemAllocNodeParams params_out = cudaMemAllocNodeParams()
+    err = cyruntime.cudaGraphMemAllocNodeGetParams(cynode, <cyruntime.cudaMemAllocNodeParams*>params_out._ptr)
+    return (cudaError_t(err), params_out)
 {{endif}}
 
-{{if 'cudaGraphEventRecordNodeSetEvent' in found_functions}}
+{{if 'cudaGraphAddMemFreeNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphEventRecordNodeSetEvent(node, event):
-    """ Sets an event record node's event.
-
-    Sets the event of event record node `hNode` to `event`.
+def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies, dptr):
+    """ Creates a memory free node and adds it to a graph.
 
-    Parameters
-    ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the event for
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Event to use
+    Creates a new memory free node and adds it to `graph` with
+    `numDependencies` dependencies specified via `pDependencies` and
+    address specified in `dptr`. It is possible for `numDependencies` to be
+    0, in which case the node will be placed at the root of the graph.
+    `pDependencies` may not have any duplicate entries. A handle to the new
+    node will be returned in `pGraphNode`.
 
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    :py:obj:`~.cudaGraphAddMemFreeNode` will return
+    :py:obj:`~.cudaErrorInvalidValue` if the user attempts to free:
 
-    See Also
-    --------
-    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
-    """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
+    - an allocation twice in the same graph.
 
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-    else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    - an address that was not returned by an allocation node.
 
-    err = ccudart.cudaGraphEventRecordNodeSetEvent(cnode, cevent)
-    return (cudaError_t(err),)
-{{endif}}
+    - an invalid address.
 
-{{if 'cudaGraphAddEventWaitNode' in found_functions}}
+    The following restrictions apply to graphs which contain allocation
+    and/or memory free nodes:
 
-@cython.embedsignature(True)
-def cudaGraphAddEventWaitNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, event):
-    """ Creates an event wait node and adds it to a graph.
+    - Nodes and edges of the graph cannot be deleted.
 
-    Creates a new event wait node and adds it to `hGraph` with
-    `numDependencies` dependencies specified via `dependencies` and event
-    specified in `event`. It is possible for `numDependencies` to be 0, in
-    which case the node will be placed at the root of the graph.
-    `dependencies` may not have any duplicate entries. A handle to the new
-    node will be returned in `phGraphNode`.
+    - The graph cannot be used in a child node.
 
-    The graph node will wait for all work captured in `event`. See
-    :py:obj:`~.cuEventRecord()` for details on what is captured by an
-    event. The synchronization will be performed efficiently on the device
-    when applicable. `event` may be from a different context or device than
-    the launch stream.
+    - Only one instantiation of the graph may exist at any point in time.
 
-    These nodes may not be used in loops or conditionals.
+    - The graph cannot be cloned.
 
     Parameters
     ----------
-    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
         Graph to which to add the node
-    dependencies : List[:py:obj:`~.cudaGraphNode_t`]
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
         Dependencies of the node
     numDependencies : size_t
         Number of dependencies
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Event for the node
+    dptr : Any
+        Address of memory to free
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    phGraphNode : :py:obj:`~.cudaGraphNode_t`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorCudartUnloading`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOutOfMemory`
+    pGraphNode : :py:obj:`~.cudaGraphNode_t`
         Returns newly created node
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
+    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
     pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in pDependencies):
+        raise TypeError("Argument 'pDependencies' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
     if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
+        cypDependencies = <cyruntime.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
         else:
             for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
+                cypDependencies[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
     if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphAddEventWaitNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cevent)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
+    cydptr = utils.HelperInputVoidPtr(dptr)
+    cdef void* cydptr_ptr = <void*><void_ptr>cydptr.cptr
+    err = cyruntime.cudaGraphAddMemFreeNode(<cyruntime.cudaGraphNode_t*>pGraphNode._ptr, cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cypDependencies, numDependencies, cydptr_ptr)
+    if cypDependencies is not NULL:
+        free(cypDependencies)
     return (cudaError_t(err), pGraphNode)
 {{endif}}
 
-{{if 'cudaGraphEventWaitNodeGetEvent' in found_functions}}
+{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphEventWaitNodeGetEvent(node):
-    """ Returns the event associated with an event wait node.
+def cudaGraphMemFreeNodeGetParams(node):
+    """ Returns a memory free node's parameters.
 
-    Returns the event of event wait node `hNode` in `event_out`.
+    Returns the address of a memory free node `hNode` in `dptr_out`.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the event for
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to get the parameters for
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    event_out : :py:obj:`~.cudaEvent_t`
-        Pointer to return the event
+    dptr_out : Any
+        Pointer to return the device address
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
+    :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaEvent_t event_out = cudaEvent_t()
-    err = ccudart.cudaGraphEventWaitNodeGetEvent(cnode, <ccudart.cudaEvent_t*>event_out._ptr)
-    return (cudaError_t(err), event_out)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef void_ptr dptr_out = 0
+    cdef void* cydptr_out_ptr = <void*>&dptr_out
+    err = cyruntime.cudaGraphMemFreeNodeGetParams(cynode, cydptr_out_ptr)
+    return (cudaError_t(err), dptr_out)
 {{endif}}
 
-{{if 'cudaGraphEventWaitNodeSetEvent' in found_functions}}
+{{if 'cudaDeviceGraphMemTrim' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphEventWaitNodeSetEvent(node, event):
-    """ Sets an event wait node's event.
+def cudaDeviceGraphMemTrim(int device):
+    """ Free unused memory that was cached on the specified device for use with graphs back to the OS.
 
-    Sets the event of event wait node `hNode` to `event`.
+    Blocks which are not in use by a graph that is either currently
+    executing or scheduled to execute are freed back to the operating
+    system.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the event for
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Event to use
+    device : int
+        The device for which cached memory should be freed.
 
     Returns
     -------
@@ -22910,637 +23313,563 @@ def cudaGraphEventWaitNodeSetEvent(node, event):
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`
+    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-    else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    err = ccudart.cudaGraphEventWaitNodeSetEvent(cnode, cevent)
+    err = cyruntime.cudaDeviceGraphMemTrim(device)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddExternalSemaphoresSignalNode' in found_functions}}
+{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddExternalSemaphoresSignalNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
-    """ Creates an external semaphore signal node and adds it to a graph.
+def cudaDeviceGetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType):
+    """ Query asynchronous allocation attributes related to graphs.
 
-    Creates a new external semaphore signal node and adds it to `graph`
-    with `numDependencies` dependencies specified via `dependencies` and
-    arguments specified in `nodeParams`. It is possible for
-    `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `dependencies` may not have any duplicate entries. A
-    handle to the new node will be returned in `pGraphNode`.
+    Valid attributes are:
 
-    Performs a signal operation on a set of externally allocated semaphore
-    objects when the node is launched. The operation(s) will occur after
-    all of the node's dependencies have completed.
+    - :py:obj:`~.cudaGraphMemAttrUsedMemCurrent`: Amount of memory, in
+      bytes, currently associated with graphs
+
+    - :py:obj:`~.cudaGraphMemAttrUsedMemHigh`: High watermark of memory, in
+      bytes, associated with graphs since the last time it was reset. High
+      watermark can only be reset to zero.
+
+    - :py:obj:`~.cudaGraphMemAttrReservedMemCurrent`: Amount of memory, in
+      bytes, currently allocated for use by the CUDA graphs asynchronous
+      allocator.
+
+    - :py:obj:`~.cudaGraphMemAttrReservedMemHigh`: High watermark of
+      memory, in bytes, currently allocated for use by the CUDA graphs
+      asynchronous allocator.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Dependencies of the node
-    numDependencies : size_t
-        Number of dependencies
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
-        Parameters for the node
+    device : int
+        Specifies the scope of the query
+    attr : :py:obj:`~.cudaGraphMemAttributeType`
+        attribute to get
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
-        Returns newly created node
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
+    value : Any
+        retrieved value
 
     See Also
     --------
-    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeGetParams`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
+    :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
     """
-    pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-    else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaExternalSemaphoreSignalNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphAddExternalSemaphoresSignalNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cnodeParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pGraphNode)
+    cdef cyruntime.cudaGraphMemAttributeType cyattr = attr.value
+    cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cyruntime.cudaDeviceGetGraphMemAttribute(device, cyattr, cyvalue_ptr)
+    return (cudaError_t(err), cyvalue.pyObj())
 {{endif}}
 
-{{if 'cudaGraphExternalSemaphoresSignalNodeGetParams' in found_functions}}
+{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExternalSemaphoresSignalNodeGetParams(hNode):
-    """ Returns an external semaphore signal node's parameters.
+def cudaDeviceSetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType, value):
+    """ Set asynchronous allocation attributes related to graphs.
 
-    Returns the parameters of an external semaphore signal node `hNode` in
-    `params_out`. The `extSemArray` and `paramsArray` returned in
-    `params_out`, are owned by the node. This memory remains valid until
-    the node is destroyed or its parameters are modified, and should not be
-    modified directly. Use
-    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams` to update
-    the parameters of this node.
+    Valid attributes are:
+
+    - :py:obj:`~.cudaGraphMemAttrUsedMemHigh`: High watermark of memory, in
+      bytes, associated with graphs since the last time it was reset. High
+      watermark can only be reset to zero.
+
+    - :py:obj:`~.cudaGraphMemAttrReservedMemHigh`: High watermark of
+      memory, in bytes, currently allocated for use by the CUDA graphs
+      asynchronous allocator.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+    device : int
+        Specifies the scope of the query
+    attr : :py:obj:`~.cudaGraphMemAttributeType`
+        attribute to get
+    value : Any
+        pointer to value to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    params_out : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
-        Pointer to return the parameters
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
+    :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-    else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef cudaExternalSemaphoreSignalNodeParams params_out = cudaExternalSemaphoreSignalNodeParams()
-    err = ccudart.cudaGraphExternalSemaphoresSignalNodeGetParams(chNode, params_out._ptr)
-    return (cudaError_t(err), params_out)
+    cdef cyruntime.cudaGraphMemAttributeType cyattr = attr.value
+    cdef utils.HelperCUgraphMem_attribute cyvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
+    cdef void* cyvalue_ptr = <void*><void_ptr>cyvalue.cptr
+    err = cyruntime.cudaDeviceSetGraphMemAttribute(device, cyattr, cyvalue_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExternalSemaphoresSignalNodeSetParams' in found_functions}}
+{{if 'cudaGraphClone' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExternalSemaphoresSignalNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
-    """ Sets an external semaphore signal node's parameters.
+def cudaGraphClone(originalGraph):
+    """ Clones a graph.
 
-    Sets the parameters of an external semaphore signal node `hNode` to
-    `nodeParams`.
+    This function creates a copy of `originalGraph` and returns it in
+    `pGraphClone`. All parameters are copied into the cloned graph. The
+    original graph may be modified after this call without affecting the
+    clone.
+
+    Child graph nodes in the original graph are recursively copied into the
+    clone.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the parameters for
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
-        Parameters to copy
+    originalGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to clone
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
+    pGraphClone : :py:obj:`~.cudaGraph_t`
+        Returns newly created cloned graph
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
+    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphNodeFindInClone`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraph_t cyoriginalGraph
+    if originalGraph is None:
+        cyoriginalGraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(originalGraph, (cudaGraph_t,driver.CUgraph)):
+        poriginalGraph = int(originalGraph)
+        cyoriginalGraph = <cyruntime.cudaGraph_t><void_ptr>poriginalGraph
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaExternalSemaphoreSignalNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphExternalSemaphoresSignalNodeSetParams(chNode, cnodeParams_ptr)
-    return (cudaError_t(err),)
+        poriginalGraph = int(cudaGraph_t(originalGraph))
+        cyoriginalGraph = <cyruntime.cudaGraph_t><void_ptr>poriginalGraph
+    cdef cudaGraph_t pGraphClone = cudaGraph_t()
+    err = cyruntime.cudaGraphClone(<cyruntime.cudaGraph_t*>pGraphClone._ptr, cyoriginalGraph)
+    return (cudaError_t(err), pGraphClone)
 {{endif}}
 
-{{if 'cudaGraphAddExternalSemaphoresWaitNode' in found_functions}}
+{{if 'cudaGraphNodeFindInClone' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddExternalSemaphoresWaitNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
-    """ Creates an external semaphore wait node and adds it to a graph.
+def cudaGraphNodeFindInClone(originalNode, clonedGraph):
+    """ Finds a cloned version of a node.
 
-    Creates a new external semaphore wait node and adds it to `graph` with
-    `numDependencies` dependencies specified via `dependencies` and
-    arguments specified in `nodeParams`. It is possible for
-    `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `dependencies` may not have any duplicate entries. A
-    handle to the new node will be returned in `pGraphNode`.
+    This function returns the node in `clonedGraph` corresponding to
+    `originalNode` in the original graph.
 
-    Performs a wait operation on a set of externally allocated semaphore
-    objects when the node is launched. The node's dependencies will not be
-    launched until the wait operation has completed.
+    `clonedGraph` must have been cloned from `originalGraph` via
+    :py:obj:`~.cudaGraphClone`. `originalNode` must have been in
+    `originalGraph` at the time of the call to :py:obj:`~.cudaGraphClone`,
+    and the corresponding cloned node in `clonedGraph` must not have been
+    removed. The cloned node is then returned via `pClonedNode`.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Dependencies of the node
-    numDependencies : size_t
-        Number of dependencies
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
-        Parameters for the node
+    originalNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Handle to the original node
+    clonedGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Cloned graph to query
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
-        Returns newly created node
+    pNode : :py:obj:`~.cudaGraphNode_t`
+        Returns handle to the cloned node
 
     See Also
     --------
-    :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeGetParams`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`,
+    :py:obj:`~.cudaGraphClone`
     """
-    pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraph_t cyclonedGraph
+    if clonedGraph is None:
+        cyclonedGraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(clonedGraph, (cudaGraph_t,driver.CUgraph)):
+        pclonedGraph = int(clonedGraph)
+        cyclonedGraph = <cyruntime.cudaGraph_t><void_ptr>pclonedGraph
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaExternalSemaphoreWaitNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphAddExternalSemaphoresWaitNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cnodeParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pGraphNode)
+        pclonedGraph = int(cudaGraph_t(clonedGraph))
+        cyclonedGraph = <cyruntime.cudaGraph_t><void_ptr>pclonedGraph
+    cdef cyruntime.cudaGraphNode_t cyoriginalNode
+    if originalNode is None:
+        cyoriginalNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(originalNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        poriginalNode = int(originalNode)
+        cyoriginalNode = <cyruntime.cudaGraphNode_t><void_ptr>poriginalNode
+    else:
+        poriginalNode = int(cudaGraphNode_t(originalNode))
+        cyoriginalNode = <cyruntime.cudaGraphNode_t><void_ptr>poriginalNode
+    cdef cudaGraphNode_t pNode = cudaGraphNode_t()
+    err = cyruntime.cudaGraphNodeFindInClone(<cyruntime.cudaGraphNode_t*>pNode._ptr, cyoriginalNode, cyclonedGraph)
+    return (cudaError_t(err), pNode)
 {{endif}}
 
-{{if 'cudaGraphExternalSemaphoresWaitNodeGetParams' in found_functions}}
+{{if 'cudaGraphNodeGetType' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExternalSemaphoresWaitNodeGetParams(hNode):
-    """ Returns an external semaphore wait node's parameters.
+def cudaGraphNodeGetType(node):
+    """ Returns a node's type.
 
-    Returns the parameters of an external semaphore wait node `hNode` in
-    `params_out`. The `extSemArray` and `paramsArray` returned in
-    `params_out`, are owned by the node. This memory remains valid until
-    the node is destroyed or its parameters are modified, and should not be
-    modified directly. Use
-    :py:obj:`~.cudaGraphExternalSemaphoresSignalNodeSetParams` to update
-    the parameters of this node.
+    Returns the node type of `node` in `pType`.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to query
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    params_out : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
-        Pointer to return the parameters
+    pType : :py:obj:`~.cudaGraphNodeType`
+        Pointer to return the node type
 
     See Also
     --------
-    :py:obj:`~.cudaLaunchKernel`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
+    :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphKernelNodeGetParams`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphHostNodeGetParams`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemsetNodeGetParams`, :py:obj:`~.cudaGraphMemsetNodeSetParams`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef cudaExternalSemaphoreWaitNodeParams params_out = cudaExternalSemaphoreWaitNodeParams()
-    err = ccudart.cudaGraphExternalSemaphoresWaitNodeGetParams(chNode, params_out._ptr)
-    return (cudaError_t(err), params_out)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNodeType pType
+    err = cyruntime.cudaGraphNodeGetType(cynode, &pType)
+    return (cudaError_t(err), cudaGraphNodeType(pType))
 {{endif}}
 
-{{if 'cudaGraphExternalSemaphoresWaitNodeSetParams' in found_functions}}
+{{if 'cudaGraphGetNodes' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExternalSemaphoresWaitNodeSetParams(hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
-    """ Sets an external semaphore wait node's parameters.
+def cudaGraphGetNodes(graph, size_t numNodes = 0):
+    """ Returns a graph's nodes.
 
-    Sets the parameters of an external semaphore wait node `hNode` to
-    `nodeParams`.
+    Returns a list of `graph's` nodes. `nodes` may be NULL, in which case
+    this function will return the number of nodes in `numNodes`. Otherwise,
+    `numNodes` entries will be filled in. If `numNodes` is higher than the
+    actual number of nodes, the remaining entries in `nodes` will be set to
+    NULL, and the number of nodes actually obtained will be returned in
+    `numNodes`.
 
     Parameters
     ----------
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to set the parameters for
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
-        Parameters to copy
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to query
+    numNodes : int
+        See description
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    nodes : List[:py:obj:`~.cudaGraphNode_t`]
+        Pointer to return the nodes
+    numNodes : int
+        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`
+    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetType`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef size_t _graph_length = numNodes
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaExternalSemaphoreWaitNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphExternalSemaphoresWaitNodeSetParams(chNode, cnodeParams_ptr)
-    return (cudaError_t(err),)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t* cynodes = NULL
+    pynodes = []
+    if _graph_length != 0:
+        cynodes = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cynodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    err = cyruntime.cudaGraphGetNodes(cygraph, cynodes, &numNodes)
+    if cudaError_t(err) == cudaError_t(0):
+        pynodes = [cudaGraphNode_t(init_value=<void_ptr>cynodes[idx]) for idx in range(_graph_length)]
+    if cynodes is not NULL:
+        free(cynodes)
+    return (cudaError_t(err), pynodes, numNodes)
 {{endif}}
 
-{{if 'cudaGraphAddMemAllocNode' in found_functions}}
+{{if 'cudaGraphGetRootNodes' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddMemAllocNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, nodeParams : Optional[cudaMemAllocNodeParams]):
-    """ Creates an allocation node and adds it to a graph.
-
-    Creates a new allocation node and adds it to `graph` with
-    `numDependencies` dependencies specified via `pDependencies` and
-    arguments specified in `nodeParams`. It is possible for
-    `numDependencies` to be 0, in which case the node will be placed at the
-    root of the graph. `pDependencies` may not have any duplicate entries.
-    A handle to the new node will be returned in `pGraphNode`.
-
-    When :py:obj:`~.cudaGraphAddMemAllocNode` creates an allocation node,
-    it returns the address of the allocation in `nodeParams.dptr`. The
-    allocation's address remains fixed across instantiations and launches.
-
-    If the allocation is freed in the same graph, by creating a free node
-    using :py:obj:`~.cudaGraphAddMemFreeNode`, the allocation can be
-    accessed by nodes ordered after the allocation node but before the free
-    node. These allocations cannot be freed outside the owning graph, and
-    they can only be freed once in the owning graph.
-
-    If the allocation is not freed in the same graph, then it can be
-    accessed not only by nodes in the graph which are ordered after the
-    allocation node, but also by stream operations ordered after the
-    graph's execution but before the allocation is freed.
-
-    Allocations which are not freed in the same graph can be freed by:
-
-    - passing the allocation to :py:obj:`~.cudaMemFreeAsync` or
-      :py:obj:`~.cudaMemFree`;
-
-    - launching a graph with a free node for that allocation; or
-
-    - specifying :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`
-      during instantiation, which makes each launch behave as though it
-      called :py:obj:`~.cudaMemFreeAsync` for every unfreed allocation.
-
-    It is not possible to free an allocation in both the owning graph and
-    another graph. If the allocation is freed in the same graph, a free
-    node cannot be added to another graph. If the allocation is freed in
-    another graph, a free node can no longer be added to the owning graph.
-
-    The following restrictions apply to graphs which contain allocation
-    and/or memory free nodes:
-
-    - Nodes and edges of the graph cannot be deleted.
-
-    - The graph cannot be used in a child node.
-
-    - Only one instantiation of the graph may exist at any point in time.
+def cudaGraphGetRootNodes(graph, size_t pNumRootNodes = 0):
+    """ Returns a graph's root nodes.
 
-    - The graph cannot be cloned.
+    Returns a list of `graph's` root nodes. `pRootNodes` may be NULL, in
+    which case this function will return the number of root nodes in
+    `pNumRootNodes`. Otherwise, `pNumRootNodes` entries will be filled in.
+    If `pNumRootNodes` is higher than the actual number of root nodes, the
+    remaining entries in `pRootNodes` will be set to NULL, and the number
+    of nodes actually obtained will be returned in `pNumRootNodes`.
 
     Parameters
     ----------
     graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Dependencies of the node
-    numDependencies : size_t
-        Number of dependencies
-    nodeParams : :py:obj:`~.cudaMemAllocNodeParams`
-        Parameters for the node
+        Graph to query
+    pNumRootNodes : int
+        See description
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorCudartUnloading`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOutOfMemory`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
-        Returns newly created node
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pRootNodes : List[:py:obj:`~.cudaGraphNode_t`]
+        Pointer to return the root nodes
+    pNumRootNodes : int
+        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaGraphMemAllocNodeGetParams`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetType`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
     """
-    pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
+    cdef size_t _graph_length = pNumRootNodes
+    cdef cyruntime.cudaGraph_t cygraph
     if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
         pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
         pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdef ccudart.cudaMemAllocNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphAddMemAllocNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cnodeParams_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pGraphNode)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t* cypRootNodes = NULL
+    pypRootNodes = []
+    if _graph_length != 0:
+        cypRootNodes = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cypRootNodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    err = cyruntime.cudaGraphGetRootNodes(cygraph, cypRootNodes, &pNumRootNodes)
+    if cudaError_t(err) == cudaError_t(0):
+        pypRootNodes = [cudaGraphNode_t(init_value=<void_ptr>cypRootNodes[idx]) for idx in range(_graph_length)]
+    if cypRootNodes is not NULL:
+        free(cypRootNodes)
+    return (cudaError_t(err), pypRootNodes, pNumRootNodes)
 {{endif}}
 
-{{if 'cudaGraphMemAllocNodeGetParams' in found_functions}}
+{{if 'cudaGraphGetEdges' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemAllocNodeGetParams(node):
-    """ Returns a memory alloc node's parameters.
+def cudaGraphGetEdges(graph, size_t numEdges = 0):
+    """ Returns a graph's dependency edges.
 
-    Returns the parameters of a memory alloc node `hNode` in `params_out`.
-    The `poolProps` and `accessDescs` returned in `params_out`, are owned
-    by the node. This memory remains valid until the node is destroyed. The
-    returned parameters must not be modified.
+    Returns a list of `graph's` dependency edges. Edges are returned via
+    corresponding indices in `from` and `to`; that is, the node in `to`[i]
+    has a dependency on the node in `from`[i]. `from` and `to` may both be
+    NULL, in which case this function only returns the number of edges in
+    `numEdges`. Otherwise, `numEdges` entries will be filled in. If
+    `numEdges` is higher than the actual number of edges, the remaining
+    entries in `from` and `to` will be set to NULL, and the number of edges
+    actually returned will be written to `numEdges`.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to get the edges from
+    numEdges : int
+        See description
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    params_out : :py:obj:`~.cudaMemAllocNodeParams`
-        Pointer to return the parameters
+    from : List[:py:obj:`~.cudaGraphNode_t`]
+        Location to return edge endpoints
+    to : List[:py:obj:`~.cudaGraphNode_t`]
+        Location to return edge endpoints
+    numEdges : int
+        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`
+    :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef size_t _graph_length = numEdges
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef cudaMemAllocNodeParams params_out = cudaMemAllocNodeParams()
-    err = ccudart.cudaGraphMemAllocNodeGetParams(cnode, params_out._ptr)
-    return (cudaError_t(err), params_out)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t* cyfrom_ = NULL
+    pyfrom_ = []
+    if _graph_length != 0:
+        cyfrom_ = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    cdef cyruntime.cudaGraphNode_t* cyto = NULL
+    pyto = []
+    if _graph_length != 0:
+        cyto = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    err = cyruntime.cudaGraphGetEdges(cygraph, cyfrom_, cyto, &numEdges)
+    if cudaError_t(err) == cudaError_t(0):
+        pyfrom_ = [cudaGraphNode_t(init_value=<void_ptr>cyfrom_[idx]) for idx in range(_graph_length)]
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
+    if cudaError_t(err) == cudaError_t(0):
+        pyto = [cudaGraphNode_t(init_value=<void_ptr>cyto[idx]) for idx in range(_graph_length)]
+    if cyto is not NULL:
+        free(cyto)
+    return (cudaError_t(err), pyfrom_, pyto, numEdges)
 {{endif}}
 
-{{if 'cudaGraphAddMemFreeNode' in found_functions}}
+{{if 'cudaGraphNodeGetDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddMemFreeNode(graph, pDependencies : Optional[List[cudaGraphNode_t]], size_t numDependencies, dptr):
-    """ Creates a memory free node and adds it to a graph.
-
-    Creates a new memory free node and adds it to `graph` with
-    `numDependencies` dependencies specified via `pDependencies` and
-    address specified in `dptr`. It is possible for `numDependencies` to be
-    0, in which case the node will be placed at the root of the graph.
-    `pDependencies` may not have any duplicate entries. A handle to the new
-    node will be returned in `pGraphNode`.
-
-    :py:obj:`~.cudaGraphAddMemFreeNode` will return
-    :py:obj:`~.cudaErrorInvalidValue` if the user attempts to free:
-
-    - an allocation twice in the same graph.
-
-    - an address that was not returned by an allocation node.
-
-    - an invalid address.
-
-    The following restrictions apply to graphs which contain allocation
-    and/or memory free nodes:
-
-    - Nodes and edges of the graph cannot be deleted.
-
-    - The graph cannot be used in a child node.
-
-    - Only one instantiation of the graph may exist at any point in time.
+def cudaGraphNodeGetDependencies(node, size_t pNumDependencies = 0):
+    """ Returns a node's dependencies.
 
-    - The graph cannot be cloned.
+    Returns a list of `node's` dependencies. `pDependencies` may be NULL,
+    in which case this function will return the number of dependencies in
+    `pNumDependencies`. Otherwise, `pNumDependencies` entries will be
+    filled in. If `pNumDependencies` is higher than the actual number of
+    dependencies, the remaining entries in `pDependencies` will be set to
+    NULL, and the number of nodes actually obtained will be returned in
+    `pNumDependencies`.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which to add the node
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Dependencies of the node
-    numDependencies : size_t
-        Number of dependencies
-    dptr : Any
-        Address of memory to free
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to query
+    pNumDependencies : int
+        See description
 
     Returns
     -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorCudartUnloading`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOutOfMemory`
-    pGraphNode : :py:obj:`~.cudaGraphNode_t`
-        Returns newly created node
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
+        Pointer to return the dependencies
+    pNumDependencies : int
+        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphDestroyNode`, :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphNodeGetDependentNodes`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`
     """
-    pDependencies = [] if pDependencies is None else pDependencies
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in pDependencies):
-        raise TypeError("Argument 'pDependencies' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef size_t _graph_length = pNumDependencies
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphNode_t pGraphNode = cudaGraphNode_t()
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    if len(pDependencies) > 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*> calloc(len(pDependencies), sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(pDependencies)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(pDependencies)):
-                cpDependencies[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>pDependencies[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(pDependencies): raise RuntimeError("List is too small: " + str(len(pDependencies)) + " < " + str(numDependencies))
-    cdptr = utils.HelperInputVoidPtr(dptr)
-    cdef void* cdptr_ptr = <void*><void_ptr>cdptr.cptr
-    err = ccudart.cudaGraphAddMemFreeNode(<ccudart.cudaGraphNode_t*>pGraphNode._ptr, cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>pDependencies[0])._ptr if len(pDependencies) == 1 else cpDependencies, numDependencies, cdptr_ptr)
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pGraphNode)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t* cypDependencies = NULL
+    pypDependencies = []
+    if _graph_length != 0:
+        cypDependencies = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependencies is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    err = cyruntime.cudaGraphNodeGetDependencies(cynode, cypDependencies, &pNumDependencies)
+    if cudaError_t(err) == cudaError_t(0):
+        pypDependencies = [cudaGraphNode_t(init_value=<void_ptr>cypDependencies[idx]) for idx in range(_graph_length)]
+    if cypDependencies is not NULL:
+        free(cypDependencies)
+    return (cudaError_t(err), pypDependencies, pNumDependencies)
 {{endif}}
 
-{{if 'cudaGraphMemFreeNodeGetParams' in found_functions}}
+{{if 'cudaGraphNodeGetDependentNodes' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphMemFreeNodeGetParams(node):
-    """ Returns a memory free node's parameters.
+def cudaGraphNodeGetDependentNodes(node, size_t pNumDependentNodes = 0):
+    """ Returns a node's dependent nodes.
 
-    Returns the address of a memory free node `hNode` in `dptr_out`.
+    Returns a list of `node's` dependent nodes. `pDependentNodes` may be
+    NULL, in which case this function will return the number of dependent
+    nodes in `pNumDependentNodes`. Otherwise, `pNumDependentNodes` entries
+    will be filled in. If `pNumDependentNodes` is higher than the actual
+    number of dependent nodes, the remaining entries in `pDependentNodes`
+    will be set to NULL, and the number of nodes actually obtained will be
+    returned in `pNumDependentNodes`.
 
     Parameters
     ----------
     node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to get the parameters for
+        Node to query
+    pNumDependentNodes : int
+        See description
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    dptr_out : Any
-        Pointer to return the device address
+    pDependentNodes : List[:py:obj:`~.cudaGraphNode_t`]
+        Pointer to return the dependent nodes
+    pNumDependentNodes : int
+        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaGraphMemFreeNodeGetParams`
+    :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef size_t _graph_length = pNumDependentNodes
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef void_ptr dptr_out = 0
-    cdef void* cdptr_out_ptr = <void*>&dptr_out
-    err = ccudart.cudaGraphMemFreeNodeGetParams(cnode, cdptr_out_ptr)
-    return (cudaError_t(err), dptr_out)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t* cypDependentNodes = NULL
+    pypDependentNodes = []
+    if _graph_length != 0:
+        cypDependentNodes = <cyruntime.cudaGraphNode_t*>calloc(_graph_length, sizeof(cyruntime.cudaGraphNode_t))
+        if cypDependentNodes is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+    err = cyruntime.cudaGraphNodeGetDependentNodes(cynode, cypDependentNodes, &pNumDependentNodes)
+    if cudaError_t(err) == cudaError_t(0):
+        pypDependentNodes = [cudaGraphNode_t(init_value=<void_ptr>cypDependentNodes[idx]) for idx in range(_graph_length)]
+    if cypDependentNodes is not NULL:
+        free(cypDependentNodes)
+    return (cudaError_t(err), pypDependentNodes, pNumDependentNodes)
 {{endif}}
 
-{{if 'cudaDeviceGraphMemTrim' in found_functions}}
+{{if 'cudaGraphAddDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGraphMemTrim(int device):
-    """ Free unused memory that was cached on the specified device for use with graphs back to the OS.
+def cudaGraphAddDependencies(graph, from_ : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], to : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies):
+    """ Adds dependency edges to a graph.
 
-    Blocks which are not in use by a graph that is either currently
-    executing or scheduled to execute are freed back to the operating
-    system.
+    The number of dependencies to be added is defined by `numDependencies`
+    Elements in `pFrom` and `pTo` at corresponding indices define a
+    dependency. Each node in `pFrom` and `pTo` must belong to `graph`.
+
+    If `numDependencies` is 0, elements in `pFrom` and `pTo` will be
+    ignored. Specifying an existing dependency will return an error.
 
     Parameters
     ----------
-    device : int
-        The device for which cached memory should be freed.
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to which dependencies are added
+    from : List[:py:obj:`~.cudaGraphNode_t`]
+        Array of nodes that provide the dependencies
+    to : List[:py:obj:`~.cudaGraphNode_t`]
+        Array of dependent nodes
+    numDependencies : size_t
+        Number of dependencies to be added
 
     Returns
     -------
@@ -23549,897 +23878,955 @@ def cudaDeviceGraphMemTrim(int device):
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
+    :py:obj:`~.cudaGraphRemoveDependencies`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
     """
-    err = ccudart.cudaDeviceGraphMemTrim(device)
+    to = [] if to is None else to
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in to):
+        raise TypeError("Argument 'to' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    from_ = [] if from_ is None else from_
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in from_):
+        raise TypeError("Argument 'from_' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    else:
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t* cyfrom_ = NULL
+    if len(from_) > 0:
+        cyfrom_ = <cyruntime.cudaGraphNode_t*> calloc(len(from_), sizeof(cyruntime.cudaGraphNode_t))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(from_)):
+                cyfrom_[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>from_[idx])._ptr[0]
+    cdef cyruntime.cudaGraphNode_t* cyto = NULL
+    if len(to) > 0:
+        cyto = <cyruntime.cudaGraphNode_t*> calloc(len(to), sizeof(cyruntime.cudaGraphNode_t))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(to)):
+                cyto[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>to[idx])._ptr[0]
+    if numDependencies > <size_t>len(from_): raise RuntimeError("List is too small: " + str(len(from_)) + " < " + str(numDependencies))
+    if numDependencies > <size_t>len(to): raise RuntimeError("List is too small: " + str(len(to)) + " < " + str(numDependencies))
+    err = cyruntime.cudaGraphAddDependencies(cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>from_[0])._ptr if len(from_) == 1 else cyfrom_, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>to[0])._ptr if len(to) == 1 else cyto, numDependencies)
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
+    if cyto is not NULL:
+        free(cyto)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceGetGraphMemAttribute' in found_functions}}
+{{if 'cudaGraphRemoveDependencies' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceGetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType):
-    """ Query asynchronous allocation attributes related to graphs.
-
-    Valid attributes are:
-
-    - :py:obj:`~.cudaGraphMemAttrUsedMemCurrent`: Amount of memory, in
-      bytes, currently associated with graphs
-
-    - :py:obj:`~.cudaGraphMemAttrUsedMemHigh`: High watermark of memory, in
-      bytes, associated with graphs since the last time it was reset. High
-      watermark can only be reset to zero.
+def cudaGraphRemoveDependencies(graph, from_ : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], to : Optional[Tuple[cudaGraphNode_t] | List[cudaGraphNode_t]], size_t numDependencies):
+    """ Removes dependency edges from a graph.
 
-    - :py:obj:`~.cudaGraphMemAttrReservedMemCurrent`: Amount of memory, in
-      bytes, currently allocated for use by the CUDA graphs asynchronous
-      allocator.
+    The number of `pDependencies` to be removed is defined by
+    `numDependencies`. Elements in `pFrom` and `pTo` at corresponding
+    indices define a dependency. Each node in `pFrom` and `pTo` must belong
+    to `graph`.
 
-    - :py:obj:`~.cudaGraphMemAttrReservedMemHigh`: High watermark of
-      memory, in bytes, currently allocated for use by the CUDA graphs
-      asynchronous allocator.
+    If `numDependencies` is 0, elements in `pFrom` and `pTo` will be
+    ignored. Specifying a non-existing dependency will return an error.
 
     Parameters
     ----------
-    device : int
-        Specifies the scope of the query
-    attr : :py:obj:`~.cudaGraphMemAttributeType`
-        attribute to get
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph from which to remove dependencies
+    from : List[:py:obj:`~.cudaGraphNode_t`]
+        Array of nodes that provide the dependencies
+    to : List[:py:obj:`~.cudaGraphNode_t`]
+        Array of dependent nodes
+    numDependencies : size_t
+        Number of dependencies to be removed
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
-    value : Any
-        retrieved value
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceSetGraphMemAttribute`, :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
+    :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
     """
-    cdef ccudart.cudaGraphMemAttributeType cattr = attr.value
-    cdef utils.HelperCUgraphMem_attribute cvalue = utils.HelperCUgraphMem_attribute(attr, 0, is_getter=True)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccudart.cudaDeviceGetGraphMemAttribute(device, cattr, cvalue_ptr)
-    return (cudaError_t(err), cvalue.pyObj())
+    to = [] if to is None else to
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in to):
+        raise TypeError("Argument 'to' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    from_ = [] if from_ is None else from_
+    if not all(isinstance(_x, (cudaGraphNode_t,driver.CUgraphNode)) for _x in from_):
+        raise TypeError("Argument 'from_' is not instance of type (expected Tuple[cyruntime.cudaGraphNode_t,driver.CUgraphNode] or List[cyruntime.cudaGraphNode_t,driver.CUgraphNode]")
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    else:
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t* cyfrom_ = NULL
+    if len(from_) > 0:
+        cyfrom_ = <cyruntime.cudaGraphNode_t*> calloc(len(from_), sizeof(cyruntime.cudaGraphNode_t))
+        if cyfrom_ is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(from_)):
+                cyfrom_[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>from_[idx])._ptr[0]
+    cdef cyruntime.cudaGraphNode_t* cyto = NULL
+    if len(to) > 0:
+        cyto = <cyruntime.cudaGraphNode_t*> calloc(len(to), sizeof(cyruntime.cudaGraphNode_t))
+        if cyto is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(cyruntime.cudaGraphNode_t)))
+        else:
+            for idx in range(len(to)):
+                cyto[idx] = <cyruntime.cudaGraphNode_t>(<cudaGraphNode_t>to[idx])._ptr[0]
+    if numDependencies > <size_t>len(from_): raise RuntimeError("List is too small: " + str(len(from_)) + " < " + str(numDependencies))
+    if numDependencies > <size_t>len(to): raise RuntimeError("List is too small: " + str(len(to)) + " < " + str(numDependencies))
+    err = cyruntime.cudaGraphRemoveDependencies(cygraph, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>from_[0])._ptr if len(from_) == 1 else cyfrom_, <cyruntime.cudaGraphNode_t*>(<cudaGraphNode_t>to[0])._ptr if len(to) == 1 else cyto, numDependencies)
+    if cyfrom_ is not NULL:
+        free(cyfrom_)
+    if cyto is not NULL:
+        free(cyto)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaDeviceSetGraphMemAttribute' in found_functions}}
+{{if 'cudaGraphDestroyNode' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaDeviceSetGraphMemAttribute(int device, attr not None : cudaGraphMemAttributeType, value):
-    """ Set asynchronous allocation attributes related to graphs.
-
-    Valid attributes are:
+def cudaGraphDestroyNode(node):
+    """ Remove a node from the graph.
 
-    - :py:obj:`~.cudaGraphMemAttrUsedMemHigh`: High watermark of memory, in
-      bytes, associated with graphs since the last time it was reset. High
-      watermark can only be reset to zero.
+    Removes `node` from its graph. This operation also severs any
+    dependencies of other nodes on `node` and vice versa.
 
-    - :py:obj:`~.cudaGraphMemAttrReservedMemHigh`: High watermark of
-      memory, in bytes, currently allocated for use by the CUDA graphs
-      asynchronous allocator.
+    Dependencies cannot be removed from graphs which contain allocation or
+    free nodes. Any attempt to do so will return an error.
 
     Parameters
     ----------
-    device : int
-        Specifies the scope of the query
-    attr : :py:obj:`~.cudaGraphMemAttributeType`
-        attribute to get
-    value : Any
-        pointer to value to set
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node to remove
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaDeviceGetGraphMemAttribute`, :py:obj:`~.cudaGraphAddMemAllocNode`, :py:obj:`~.cudaGraphAddMemFreeNode`, :py:obj:`~.cudaDeviceGraphMemTrim`, :py:obj:`~.cudaMallocAsync`, :py:obj:`~.cudaFreeAsync`,
+    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
     """
-    cdef ccudart.cudaGraphMemAttributeType cattr = attr.value
-    cdef utils.HelperCUgraphMem_attribute cvalue = utils.HelperCUgraphMem_attribute(attr, value, is_getter=False)
-    cdef void* cvalue_ptr = <void*><void_ptr>cvalue.cptr
-    err = ccudart.cudaDeviceSetGraphMemAttribute(device, cattr, cvalue_ptr)
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    err = cyruntime.cudaGraphDestroyNode(cynode)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphClone' in found_functions}}
+{{if 'cudaGraphInstantiate' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphClone(originalGraph):
-    """ Clones a graph.
+def cudaGraphInstantiate(graph, char* pLogBuffer, size_t bufferSize):
+    """ Creates an executable graph from a graph.
 
-    This function creates a copy of `originalGraph` and returns it in
-    `pGraphClone`. All parameters are copied into the cloned graph. The
-    original graph may be modified after this call without affecting the
-    clone.
+    Instantiates `graph` as an executable graph. The graph is validated for
+    any structural constraints or intra-node constraints which were not
+    previously validated. If instantiation is successful, a handle to the
+    instantiated graph is returned in `pGraphExec`.
 
-    Child graph nodes in the original graph are recursively copied into the
-    clone.
+    If there are any errors, diagnostic information may be returned in
+    `pErrorNode` and `pLogBuffer`. This is the primary way to inspect
+    instantiation errors. The output will be null terminated unless the
+    diagnostics overflow the buffer. In this case, they will be truncated,
+    and the last byte can be inspected to determine if truncation occurred.
 
     Parameters
     ----------
-    originalGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to clone
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to instantiate
+    pLogBuffer : bytes
+        A character buffer to store diagnostic messages
+    bufferSize : size_t
+        Size of the log buffer in bytes
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorMemoryAllocation`
-    pGraphClone : :py:obj:`~.cudaGraph_t`
-        Returns newly created cloned graph
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    pGraphExec : :py:obj:`~.cudaGraphExec_t`
+        Returns instantiated graph
+    pErrorNode : :py:obj:`~.cudaGraphNode_t`
+        In case of an instantiation error, this may be modified to indicate
+        a node contributing to the error
 
     See Also
     --------
-    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphNodeFindInClone`
+    :py:obj:`~.cudaGraphInstantiateWithFlags`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
     """
-    cdef ccudart.cudaGraph_t coriginalGraph
-    if originalGraph is None:
-        coriginalGraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(originalGraph, (cudaGraph_t,cuda.CUgraph)):
-        poriginalGraph = int(originalGraph)
-        coriginalGraph = <ccudart.cudaGraph_t><void_ptr>poriginalGraph
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        poriginalGraph = int(cudaGraph_t(originalGraph))
-        coriginalGraph = <ccudart.cudaGraph_t><void_ptr>poriginalGraph
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
+    cdef cudaGraphNode_t pErrorNode = cudaGraphNode_t()
+    err = cyruntime.cudaGraphInstantiate(<cyruntime.cudaGraphExec_t*>pGraphExec._ptr, cygraph, <cyruntime.cudaGraphNode_t*>pErrorNode._ptr, pLogBuffer, bufferSize)
+    return (cudaError_t(err), pGraphExec, pErrorNode)
+{{endif}}
+
+{{if 'cudaGraphInstantiateWithFlags' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaGraphInstantiateWithFlags(graph, unsigned long long flags):
+    """ Creates an executable graph from a graph.
+
+    Instantiates `graph` as an executable graph. The graph is validated for
+    any structural constraints or intra-node constraints which were not
+    previously validated. If instantiation is successful, a handle to the
+    instantiated graph is returned in `pGraphExec`.
 
-    cdef cudaGraph_t pGraphClone = cudaGraph_t()
-    err = ccudart.cudaGraphClone(<ccudart.cudaGraph_t*>pGraphClone._ptr, coriginalGraph)
-    return (cudaError_t(err), pGraphClone)
-{{endif}}
+    The `flags` parameter controls the behavior of instantiation and
+    subsequent graph launches. Valid flags are:
 
-{{if 'cudaGraphNodeFindInClone' in found_functions}}
+    - :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`, which
+      configures a graph containing memory allocation nodes to
+      automatically free any unfreed memory allocations before the graph is
+      relaunched.
 
-@cython.embedsignature(True)
-def cudaGraphNodeFindInClone(originalNode, clonedGraph):
-    """ Finds a cloned version of a node.
+    - :py:obj:`~.cudaGraphInstantiateFlagUseNodePriority`, which causes the
+      graph to use the priorities from the per-node attributes rather than
+      the priority of the launch stream during execution. Note that
+      priorities are only available on kernel nodes, and are copied from
+      stream priority during stream capture.
 
-    This function returns the node in `clonedGraph` corresponding to
-    `originalNode` in the original graph.
+    If `graph` contains any allocation or free nodes, there can be at most
+    one executable graph in existence for that graph at a time.
 
-    `clonedGraph` must have been cloned from `originalGraph` via
-    :py:obj:`~.cudaGraphClone`. `originalNode` must have been in
-    `originalGraph` at the time of the call to :py:obj:`~.cudaGraphClone`,
-    and the corresponding cloned node in `clonedGraph` must not have been
-    removed. The cloned node is then returned via `pClonedNode`.
+    An attempt to instantiate a second executable graph before destroying
+    the first with :py:obj:`~.cudaGraphExecDestroy` will result in an
+    error.
 
     Parameters
     ----------
-    originalNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Handle to the original node
-    clonedGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Cloned graph to query
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to instantiate
+    flags : unsigned long long
+        Flags to control instantiation. See
+        :py:obj:`~.CUgraphInstantiate_flags`.
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pNode : :py:obj:`~.cudaGraphNode_t`
-        Returns handle to the cloned node
+    pGraphExec : :py:obj:`~.cudaGraphExec_t`
+        Returns instantiated graph
 
     See Also
     --------
-    :py:obj:`~.cudaGraphClone`
+    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
     """
-    cdef ccudart.cudaGraph_t cclonedGraph
-    if clonedGraph is None:
-        cclonedGraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(clonedGraph, (cudaGraph_t,cuda.CUgraph)):
-        pclonedGraph = int(clonedGraph)
-        cclonedGraph = <ccudart.cudaGraph_t><void_ptr>pclonedGraph
-    else:
-        pclonedGraph = int(cudaGraph_t(clonedGraph))
-        cclonedGraph = <ccudart.cudaGraph_t><void_ptr>pclonedGraph
-
-    cdef ccudart.cudaGraphNode_t coriginalNode
-    if originalNode is None:
-        coriginalNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(originalNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        poriginalNode = int(originalNode)
-        coriginalNode = <ccudart.cudaGraphNode_t><void_ptr>poriginalNode
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        poriginalNode = int(cudaGraphNode_t(originalNode))
-        coriginalNode = <ccudart.cudaGraphNode_t><void_ptr>poriginalNode
-
-    cdef cudaGraphNode_t pNode = cudaGraphNode_t()
-    err = ccudart.cudaGraphNodeFindInClone(<ccudart.cudaGraphNode_t*>pNode._ptr, coriginalNode, cclonedGraph)
-    return (cudaError_t(err), pNode)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
+    err = cyruntime.cudaGraphInstantiateWithFlags(<cyruntime.cudaGraphExec_t*>pGraphExec._ptr, cygraph, flags)
+    return (cudaError_t(err), pGraphExec)
 {{endif}}
 
-{{if 'cudaGraphNodeGetType' in found_functions}}
+{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphNodeGetType(node):
-    """ Returns a node's type.
+def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaKernelNodeParams]):
+    """ Sets the parameters for a kernel node in the given graphExec.
 
-    Returns the node type of `node` in `pType`.
+    Sets the parameters of a kernel node in an executable graph
+    `hGraphExec`. The node is identified by the corresponding node `node`
+    in the non-executable graph, from which the executable graph was
+    instantiated.
+
+    `node` must not have been removed from the original graph. The `func`
+    field of `nodeParams` cannot be modified and must match the original
+    value. All other values can be modified.
+
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
 
     Parameters
     ----------
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
     node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to query
+        kernel node from the graph from which graphExec was instantiated
+    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pType : :py:obj:`~.cudaGraphNodeType`
-        Pointer to return the node type
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphKernelNodeGetParams`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphHostNodeGetParams`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeGetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemsetNodeGetParams`, :py:obj:`~.cudaGraphMemsetNodeSetParams`
+    :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphNodeType pType
-    err = ccudart.cudaGraphNodeGetType(cnode, &pType)
-    return (cudaError_t(err), cudaGraphNodeType(pType))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaKernelNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphExecKernelNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphGetNodes' in found_functions}}
+{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphGetNodes(graph, size_t numNodes = 0):
-    """ Returns a graph's nodes.
-
-    Returns a list of `graph's` nodes. `nodes` may be NULL, in which case
-    this function will return the number of nodes in `numNodes`. Otherwise,
-    `numNodes` entries will be filled in. If `numNodes` is higher than the
-    actual number of nodes, the remaining entries in `nodes` will be set to
-    NULL, and the number of nodes actually obtained will be returned in
-    `numNodes`.
-
-    Parameters
-    ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to query
-    numNodes : int
-        See description
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    nodes : List[:py:obj:`~.cudaGraphNode_t`]
-        Pointer to return the nodes
-    numNodes : int
-        See description
-
-    See Also
-    --------
-    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetType`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
-    """
-    cdef size_t _graph_length = numNodes
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-    else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+def cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemcpy3DParms]):
+    """ Sets the parameters for a memcpy node in the given graphExec.
 
-    cdef ccudart.cudaGraphNode_t* cnodes = NULL
-    pynodes = []
-    if _graph_length != 0:
-        cnodes = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cnodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    err = ccudart.cudaGraphGetNodes(cgraph, cnodes, &numNodes)
-    if cudaError_t(err) == cudaError_t(0):
-        pynodes = [cudaGraphNode_t(init_value=<void_ptr>cnodes[idx]) for idx in range(_graph_length)]
-    if cnodes is not NULL:
-        free(cnodes)
-    return (cudaError_t(err), pynodes, numNodes)
-{{endif}}
+    Updates the work represented by `node` in `hGraphExec` as though `node`
+    had contained `pNodeParams` at instantiation. `node` must remain in the
+    graph which was used to instantiate `hGraphExec`. Changed edges to and
+    from `node` are ignored.
 
-{{if 'cudaGraphGetRootNodes' in found_functions}}
+    The source and destination memory in `pNodeParams` must be allocated
+    from the same contexts as the original source and destination memory.
+    Both the instantiation-time memory operands and the memory operands in
+    `pNodeParams` must be 1-dimensional. Zero-length operations are not
+    supported.
 
-@cython.embedsignature(True)
-def cudaGraphGetRootNodes(graph, size_t pNumRootNodes = 0):
-    """ Returns a graph's root nodes.
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
 
-    Returns a list of `graph's` root nodes. `pRootNodes` may be NULL, in
-    which case this function will return the number of root nodes in
-    `pNumRootNodes`. Otherwise, `pNumRootNodes` entries will be filled in.
-    If `pNumRootNodes` is higher than the actual number of root nodes, the
-    remaining entries in `pRootNodes` will be set to NULL, and the number
-    of nodes actually obtained will be returned in `pNumRootNodes`.
+    Returns :py:obj:`~.cudaErrorInvalidValue` if the memory operands'
+    mappings changed or either the original or new memory operands are
+    multidimensional.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to query
-    pNumRootNodes : int
-        See description
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Memcpy node from the graph which was used to instantiate graphExec
+    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pRootNodes : List[:py:obj:`~.cudaGraphNode_t`]
-        Pointer to return the root nodes
-    pNumRootNodes : int
-        See description
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetType`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
+    :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParamsToSymbol`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParamsFromSymbol`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef size_t _graph_length = pNumRootNodes
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef ccudart.cudaGraphNode_t* cpRootNodes = NULL
-    pypRootNodes = []
-    if _graph_length != 0:
-        cpRootNodes = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cpRootNodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    err = ccudart.cudaGraphGetRootNodes(cgraph, cpRootNodes, &pNumRootNodes)
-    if cudaError_t(err) == cudaError_t(0):
-        pypRootNodes = [cudaGraphNode_t(init_value=<void_ptr>cpRootNodes[idx]) for idx in range(_graph_length)]
-    if cpRootNodes is not NULL:
-        free(cpRootNodes)
-    return (cudaError_t(err), pypRootNodes, pNumRootNodes)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaMemcpy3DParms* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphExecMemcpyNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphGetEdges' in found_functions}}
+{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphGetEdges(graph, size_t numEdges = 0):
-    """ Returns a graph's dependency edges.
+def cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, size_t count, kind not None : cudaMemcpyKind):
+    """ Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional copy.
 
-    Returns a list of `graph's` dependency edges. Edges are returned via
-    corresponding indices in `from` and `to`; that is, the node in `to`[i]
-    has a dependency on the node in `from`[i]. `from` and `to` may both be
-    NULL, in which case this function only returns the number of edges in
-    `numEdges`. Otherwise, `numEdges` entries will be filled in. If
-    `numEdges` is higher than the actual number of edges, the remaining
-    entries in `from` and `to` will be set to NULL, and the number of edges
-    actually returned will be written to `numEdges`.
+    Updates the work represented by `node` in `hGraphExec` as though `node`
+    had contained the given params at instantiation. `node` must remain in
+    the graph which was used to instantiate `hGraphExec`. Changed edges to
+    and from `node` are ignored.
+
+    `src` and `dst` must be allocated from the same contexts as the
+    original source and destination memory. The instantiation-time memory
+    operands must be 1-dimensional. Zero-length operations are not
+    supported.
+
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
+
+    Returns :py:obj:`~.cudaErrorInvalidValue` if the memory operands'
+    mappings changed or the original memory operands are multidimensional.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to get the edges from
-    numEdges : int
-        See description
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Memcpy node from the graph which was used to instantiate graphExec
+    dst : Any
+        Destination memory address
+    src : Any
+        Source memory address
+    count : size_t
+        Size in bytes to copy
+    kind : :py:obj:`~.cudaMemcpyKind`
+        Type of transfer
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    from : List[:py:obj:`~.cudaGraphNode_t`]
-        Location to return edge endpoints
-    to : List[:py:obj:`~.cudaGraphNode_t`]
-        Location to return edge endpoints
-    numEdges : int
-        See description
 
     See Also
     --------
-    :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
+    :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemcpyNode1D`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef size_t _graph_length = numEdges
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef ccudart.cudaGraphNode_t* cfrom_ = NULL
-    pyfrom_ = []
-    if _graph_length != 0:
-        cfrom_ = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    cdef ccudart.cudaGraphNode_t* cto = NULL
-    pyto = []
-    if _graph_length != 0:
-        cto = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    err = ccudart.cudaGraphGetEdges(cgraph, cfrom_, cto, &numEdges)
-    if cudaError_t(err) == cudaError_t(0):
-        pyfrom_ = [cudaGraphNode_t(init_value=<void_ptr>cfrom_[idx]) for idx in range(_graph_length)]
-    if cfrom_ is not NULL:
-        free(cfrom_)
-    if cudaError_t(err) == cudaError_t(0):
-        pyto = [cudaGraphNode_t(init_value=<void_ptr>cto[idx]) for idx in range(_graph_length)]
-    if cto is not NULL:
-        free(cto)
-    return (cudaError_t(err), pyfrom_, pyto, numEdges)
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cydst = utils.HelperInputVoidPtr(dst)
+    cdef void* cydst_ptr = <void*><void_ptr>cydst.cptr
+    cysrc = utils.HelperInputVoidPtr(src)
+    cdef void* cysrc_ptr = <void*><void_ptr>cysrc.cptr
+    cdef cyruntime.cudaMemcpyKind cykind = kind.value
+    err = cyruntime.cudaGraphExecMemcpyNodeSetParams1D(cyhGraphExec, cynode, cydst_ptr, cysrc_ptr, count, cykind)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphNodeGetDependencies' in found_functions}}
+{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphNodeGetDependencies(node, size_t pNumDependencies = 0):
-    """ Returns a node's dependencies.
+def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemsetParams]):
+    """ Sets the parameters for a memset node in the given graphExec.
 
-    Returns a list of `node's` dependencies. `pDependencies` may be NULL,
-    in which case this function will return the number of dependencies in
-    `pNumDependencies`. Otherwise, `pNumDependencies` entries will be
-    filled in. If `pNumDependencies` is higher than the actual number of
-    dependencies, the remaining entries in `pDependencies` will be set to
-    NULL, and the number of nodes actually obtained will be returned in
-    `pNumDependencies`.
+    Updates the work represented by `node` in `hGraphExec` as though `node`
+    had contained `pNodeParams` at instantiation. `node` must remain in the
+    graph which was used to instantiate `hGraphExec`. Changed edges to and
+    from `node` are ignored.
+
+    The destination memory in `pNodeParams` must be allocated from the same
+    context as the original destination memory. Both the instantiation-time
+    memory operand and the memory operand in `pNodeParams` must be
+    1-dimensional. Zero-length operations are not supported.
+
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
+
+    Returns cudaErrorInvalidValue if the memory operand's mappings changed
+    or either the original or new memory operand are multidimensional.
 
     Parameters
     ----------
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
     node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to query
-    pNumDependencies : int
-        See description
+        Memset node from the graph which was used to instantiate graphExec
+    pNodeParams : :py:obj:`~.cudaMemsetParams`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pDependencies : List[:py:obj:`~.cudaGraphNode_t`]
-        Pointer to return the dependencies
-    pNumDependencies : int
-        See description
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphNodeGetDependentNodes`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`
+    :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef size_t _graph_length = pNumDependencies
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphNode_t* cpDependencies = NULL
-    pypDependencies = []
-    if _graph_length != 0:
-        cpDependencies = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cpDependencies is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    err = ccudart.cudaGraphNodeGetDependencies(cnode, cpDependencies, &pNumDependencies)
-    if cudaError_t(err) == cudaError_t(0):
-        pypDependencies = [cudaGraphNode_t(init_value=<void_ptr>cpDependencies[idx]) for idx in range(_graph_length)]
-    if cpDependencies is not NULL:
-        free(cpDependencies)
-    return (cudaError_t(err), pypDependencies, pNumDependencies)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaMemsetParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphExecMemsetNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphNodeGetDependentNodes' in found_functions}}
+{{if 'cudaGraphExecHostNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphNodeGetDependentNodes(node, size_t pNumDependentNodes = 0):
-    """ Returns a node's dependent nodes.
+def cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaHostNodeParams]):
+    """ Sets the parameters for a host node in the given graphExec.
 
-    Returns a list of `node's` dependent nodes. `pDependentNodes` may be
-    NULL, in which case this function will return the number of dependent
-    nodes in `pNumDependentNodes`. Otherwise, `pNumDependentNodes` entries
-    will be filled in. If `pNumDependentNodes` is higher than the actual
-    number of dependent nodes, the remaining entries in `pDependentNodes`
-    will be set to NULL, and the number of nodes actually obtained will be
-    returned in `pNumDependentNodes`.
+    Updates the work represented by `node` in `hGraphExec` as though `node`
+    had contained `pNodeParams` at instantiation. `node` must remain in the
+    graph which was used to instantiate `hGraphExec`. Changed edges to and
+    from `node` are ignored.
+
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
 
     Parameters
     ----------
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
     node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to query
-    pNumDependentNodes : int
-        See description
+        Host node from the graph which was used to instantiate graphExec
+    pNodeParams : :py:obj:`~.cudaHostNodeParams`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pDependentNodes : List[:py:obj:`~.cudaGraphNode_t`]
-        Pointer to return the dependent nodes
-    pNumDependentNodes : int
-        See description
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphGetNodes`, :py:obj:`~.cudaGraphGetRootNodes`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphRemoveDependencies`
+    :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef size_t _graph_length = pNumDependentNodes
-    cdef ccudart.cudaGraphNode_t cnode
+    cdef cyruntime.cudaGraphNode_t cynode
     if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
         pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
     else:
         pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphNode_t* cpDependentNodes = NULL
-    pypDependentNodes = []
-    if _graph_length != 0:
-        cpDependentNodes = <ccudart.cudaGraphNode_t*>calloc(_graph_length, sizeof(ccudart.cudaGraphNode_t))
-        if cpDependentNodes is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(_graph_length) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-    err = ccudart.cudaGraphNodeGetDependentNodes(cnode, cpDependentNodes, &pNumDependentNodes)
-    if cudaError_t(err) == cudaError_t(0):
-        pypDependentNodes = [cudaGraphNode_t(init_value=<void_ptr>cpDependentNodes[idx]) for idx in range(_graph_length)]
-    if cpDependentNodes is not NULL:
-        free(cpDependentNodes)
-    return (cudaError_t(err), pypDependentNodes, pNumDependentNodes)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaHostNodeParams* cypNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
+    err = cyruntime.cudaGraphExecHostNodeSetParams(cyhGraphExec, cynode, cypNodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphAddDependencies' in found_functions}}
+{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphAddDependencies(graph, from_ : Optional[List[cudaGraphNode_t]], to : Optional[List[cudaGraphNode_t]], size_t numDependencies):
-    """ Adds dependency edges to a graph.
+def cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph):
+    """ Updates node parameters in the child graph node in the given graphExec.
 
-    The number of dependencies to be added is defined by `numDependencies`
-    Elements in `pFrom` and `pTo` at corresponding indices define a
-    dependency. Each node in `pFrom` and `pTo` must belong to `graph`.
+    Updates the work represented by `node` in `hGraphExec` as though the
+    nodes contained in `node's` graph had the parameters contained in
+    `childGraph's` nodes at instantiation. `node` must remain in the graph
+    which was used to instantiate `hGraphExec`. Changed edges to and from
+    `node` are ignored.
 
-    If `numDependencies` is 0, elements in `pFrom` and `pTo` will be
-    ignored. Specifying an existing dependency will return an error.
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `node` is also not modified by this call.
+
+    The topology of `childGraph`, as well as the node insertion order, must
+    match that of the graph contained in `node`. See
+    :py:obj:`~.cudaGraphExecUpdate()` for a list of restrictions on what
+    can be updated in an instantiated graph. The update is recursive, so
+    child graph nodes contained within the top level child graph will also
+    be updated.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to which dependencies are added
-    from : List[:py:obj:`~.cudaGraphNode_t`]
-        Array of nodes that provide the dependencies
-    to : List[:py:obj:`~.cudaGraphNode_t`]
-        Array of dependent nodes
-    numDependencies : size_t
-        Number of dependencies to be added
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Host node from the graph which was used to instantiate graphExec
+    childGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph supplying the updated parameters
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphRemoveDependencies`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
+    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    to = [] if to is None else to
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in to):
-        raise TypeError("Argument 'to' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    from_ = [] if from_ is None else from_
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in from_):
-        raise TypeError("Argument 'from_' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraph_t cychildGraph
+    if childGraph is None:
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(childGraph, (cudaGraph_t,driver.CUgraph)):
+        pchildGraph = int(childGraph)
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>pchildGraph
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef ccudart.cudaGraphNode_t* cfrom_ = NULL
-    if len(from_) > 0:
-        cfrom_ = <ccudart.cudaGraphNode_t*> calloc(len(from_), sizeof(ccudart.cudaGraphNode_t))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(from_)):
-                cfrom_[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>from_[idx])._ptr[0]
-
-    cdef ccudart.cudaGraphNode_t* cto = NULL
-    if len(to) > 0:
-        cto = <ccudart.cudaGraphNode_t*> calloc(len(to), sizeof(ccudart.cudaGraphNode_t))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(to)):
-                cto[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>to[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(from_): raise RuntimeError("List is too small: " + str(len(from_)) + " < " + str(numDependencies))
-    if numDependencies > <size_t>len(to): raise RuntimeError("List is too small: " + str(len(to)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphAddDependencies(cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>from_[0])._ptr if len(from_) == 1 else cfrom_, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>to[0])._ptr if len(to) == 1 else cto, numDependencies)
-    if cfrom_ is not NULL:
-        free(cfrom_)
-    if cto is not NULL:
-        free(cto)
+        pchildGraph = int(cudaGraph_t(childGraph))
+        cychildGraph = <cyruntime.cudaGraph_t><void_ptr>pchildGraph
+    cdef cyruntime.cudaGraphNode_t cynode
+    if node is None:
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(node, (cudaGraphNode_t,driver.CUgraphNode)):
+        pnode = int(node)
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    else:
+        pnode = int(cudaGraphNode_t(node))
+        cynode = <cyruntime.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    err = cyruntime.cudaGraphExecChildGraphNodeSetParams(cyhGraphExec, cynode, cychildGraph)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphRemoveDependencies' in found_functions}}
+{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphRemoveDependencies(graph, from_ : Optional[List[cudaGraphNode_t]], to : Optional[List[cudaGraphNode_t]], size_t numDependencies):
-    """ Removes dependency edges from a graph.
+def cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event):
+    """ Sets the event for an event record node in the given graphExec.
 
-    The number of `pDependencies` to be removed is defined by
-    `numDependencies`. Elements in `pFrom` and `pTo` at corresponding
-    indices define a dependency. Each node in `pFrom` and `pTo` must belong
-    to `graph`.
+    Sets the event of an event record node in an executable graph
+    `hGraphExec`. The node is identified by the corresponding node `hNode`
+    in the non-executable graph, from which the executable graph was
+    instantiated.
 
-    If `numDependencies` is 0, elements in `pFrom` and `pTo` will be
-    ignored. Specifying a non-existing dependency will return an error.
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `hNode` is also not modified by this call.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph from which to remove dependencies
-    from : List[:py:obj:`~.cudaGraphNode_t`]
-        Array of nodes that provide the dependencies
-    to : List[:py:obj:`~.cudaGraphNode_t`]
-        Array of dependent nodes
-    numDependencies : size_t
-        Number of dependencies to be removed
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Event record node from the graph from which graphExec was
+        instantiated
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Updated event to use
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddDependencies`, :py:obj:`~.cudaGraphGetEdges`, :py:obj:`~.cudaGraphNodeGetDependencies`, :py:obj:`~.cudaGraphNodeGetDependentNodes`
+    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    to = [] if to is None else to
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in to):
-        raise TypeError("Argument 'to' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    from_ = [] if from_ is None else from_
-    if not all(isinstance(_x, (cudaGraphNode_t, cuda.CUgraphNode)) for _x in from_):
-        raise TypeError("Argument 'from_' is not instance of type (expected List[ccudart.cudaGraphNode_t, cuda.CUgraphNode]")
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef ccudart.cudaGraphNode_t* cfrom_ = NULL
-    if len(from_) > 0:
-        cfrom_ = <ccudart.cudaGraphNode_t*> calloc(len(from_), sizeof(ccudart.cudaGraphNode_t))
-        if cfrom_ is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(from_)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(from_)):
-                cfrom_[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>from_[idx])._ptr[0]
-
-    cdef ccudart.cudaGraphNode_t* cto = NULL
-    if len(to) > 0:
-        cto = <ccudart.cudaGraphNode_t*> calloc(len(to), sizeof(ccudart.cudaGraphNode_t))
-        if cto is NULL:
-            raise MemoryError('Failed to allocate length x size memory: ' + str(len(to)) + 'x' + str(sizeof(ccudart.cudaGraphNode_t)))
-        else:
-            for idx in range(len(to)):
-                cto[idx] = <ccudart.cudaGraphNode_t>(<cudaGraphNode_t>to[idx])._ptr[0]
-
-    if numDependencies > <size_t>len(from_): raise RuntimeError("List is too small: " + str(len(from_)) + " < " + str(numDependencies))
-    if numDependencies > <size_t>len(to): raise RuntimeError("List is too small: " + str(len(to)) + " < " + str(numDependencies))
-    err = ccudart.cudaGraphRemoveDependencies(cgraph, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>from_[0])._ptr if len(from_) == 1 else cfrom_, <ccudart.cudaGraphNode_t*>(<cudaGraphNode_t>to[0])._ptr if len(to) == 1 else cto, numDependencies)
-    if cfrom_ is not NULL:
-        free(cfrom_)
-    if cto is not NULL:
-        free(cto)
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    else:
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    err = cyruntime.cudaGraphExecEventRecordNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphDestroyNode' in found_functions}}
+{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphDestroyNode(node):
-    """ Remove a node from the graph.
+def cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event):
+    """ Sets the event for an event wait node in the given graphExec.
 
-    Removes `node` from its graph. This operation also severs any
-    dependencies of other nodes on `node` and vice versa.
+    Sets the event of an event wait node in an executable graph
+    `hGraphExec`. The node is identified by the corresponding node `hNode`
+    in the non-executable graph, from which the executable graph was
+    instantiated.
 
-    Dependencies cannot be removed from graphs which contain allocation or
-    free nodes. Any attempt to do so will return an error.
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `hNode` is also not modified by this call.
 
     Parameters
     ----------
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node to remove
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Event wait node from the graph from which graphExec was
+        instantiated
+    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
+        Updated event to use
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphAddEmptyNode`, :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemsetNode`
+    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaEvent_t cyevent
+    if event is None:
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>0
+    elif isinstance(event, (cudaEvent_t,driver.CUevent)):
+        pevent = int(event)
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    err = ccudart.cudaGraphDestroyNode(cnode)
+        pevent = int(cudaEvent_t(event))
+        cyevent = <cyruntime.cudaEvent_t><void_ptr>pevent
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    else:
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    err = cyruntime.cudaGraphExecEventWaitNodeSetEvent(cyhGraphExec, cyhNode, cyevent)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphInstantiate' in found_functions}}
+{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphInstantiate(graph, char* pLogBuffer, size_t bufferSize):
-    """ Creates an executable graph from a graph.
+def cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
+    """ Sets the parameters for an external semaphore signal node in the given graphExec.
 
-    Instantiates `graph` as an executable graph. The graph is validated for
-    any structural constraints or intra-node constraints which were not
-    previously validated. If instantiation is successful, a handle to the
-    instantiated graph is returned in `pGraphExec`.
+    Sets the parameters of an external semaphore signal node in an
+    executable graph `hGraphExec`. The node is identified by the
+    corresponding node `hNode` in the non-executable graph, from which the
+    executable graph was instantiated.
 
-    If there are any errors, diagnostic information may be returned in
-    `pErrorNode` and `pLogBuffer`. This is the primary way to inspect
-    instantiation errors. The output will be null terminated unless the
-    diagnostics overflow the buffer. In this case, they will be truncated,
-    and the last byte can be inspected to determine if truncation occurred.
+    `hNode` must not have been removed from the original graph.
+
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `hNode` is also not modified by this call.
+
+    Changing `nodeParams->numExtSems` is not supported.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to instantiate
-    pLogBuffer : bytes
-        A character buffer to store diagnostic messages
-    bufferSize : size_t
-        Size of the log buffer in bytes
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        semaphore signal node from the graph from which graphExec was
+        instantiated
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraphExec : :py:obj:`~.cudaGraphExec_t`
-        Returns instantiated graph
-    pErrorNode : :py:obj:`~.cudaGraphNode_t`
-        In case of an instantiation error, this may be modified to indicate
-        a node contributing to the error
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiateWithFlags`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
+    :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
-    cdef cudaGraphNode_t pErrorNode = cudaGraphNode_t()
-    err = ccudart.cudaGraphInstantiate(<ccudart.cudaGraphExec_t*>pGraphExec._ptr, cgraph, <ccudart.cudaGraphNode_t*>pErrorNode._ptr, pLogBuffer, bufferSize)
-    return (cudaError_t(err), pGraphExec, pErrorNode)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaExternalSemaphoreSignalNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphExecExternalSemaphoresSignalNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphInstantiateWithFlags' in found_functions}}
+{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphInstantiateWithFlags(graph, unsigned long long flags):
-    """ Creates an executable graph from a graph.
-
-    Instantiates `graph` as an executable graph. The graph is validated for
-    any structural constraints or intra-node constraints which were not
-    previously validated. If instantiation is successful, a handle to the
-    instantiated graph is returned in `pGraphExec`.
-
-    The `flags` parameter controls the behavior of instantiation and
-    subsequent graph launches. Valid flags are:
+def cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
+    """ Sets the parameters for an external semaphore wait node in the given graphExec.
 
-    - :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`, which
-      configures a graph containing memory allocation nodes to
-      automatically free any unfreed memory allocations before the graph is
-      relaunched.
+    Sets the parameters of an external semaphore wait node in an executable
+    graph `hGraphExec`. The node is identified by the corresponding node
+    `hNode` in the non-executable graph, from which the executable graph
+    was instantiated.
 
-    - :py:obj:`~.cudaGraphInstantiateFlagUseNodePriority`, which causes the
-      graph to use the priorities from the per-node attributes rather than
-      the priority of the launch stream during execution. Note that
-      priorities are only available on kernel nodes, and are copied from
-      stream priority during stream capture.
+    `hNode` must not have been removed from the original graph.
 
-    If `graph` contains any allocation or free nodes, there can be at most
-    one executable graph in existence for that graph at a time.
+    The modifications only affect future launches of `hGraphExec`. Already
+    enqueued or running launches of `hGraphExec` are not affected by this
+    call. `hNode` is also not modified by this call.
 
-    An attempt to instantiate a second executable graph before destroying
-    the first with :py:obj:`~.cudaGraphExecDestroy` will result in an
-    error.
+    Changing `nodeParams->numExtSems` is not supported.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to instantiate
-    flags : unsigned long long
-        Flags to control instantiation. See
-        :py:obj:`~.CUgraphInstantiate_flags`.
+    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        The executable graph in which to set the specified node
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        semaphore wait node from the graph from which graphExec was
+        instantiated
+    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
+        Updated Parameters to set
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    pGraphExec : :py:obj:`~.cudaGraphExec_t`
-        Returns instantiated graph
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphCreate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
+    :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
     """
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    cdef cudaGraphExec_t pGraphExec = cudaGraphExec_t()
-    err = ccudart.cudaGraphInstantiateWithFlags(<ccudart.cudaGraphExec_t*>pGraphExec._ptr, cgraph, flags)
-    return (cudaError_t(err), pGraphExec)
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
+    if hGraphExec is None:
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        phGraphExec = int(hGraphExec)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    else:
+        phGraphExec = int(cudaGraphExec_t(hGraphExec))
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaExternalSemaphoreWaitNodeParams* cynodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
+    err = cyruntime.cudaGraphExecExternalSemaphoresWaitNodeSetParams(cyhGraphExec, cyhNode, cynodeParams_ptr)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecKernelNodeSetParams' in found_functions}}
+{{if 'cudaGraphNodeSetEnabled' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaKernelNodeParams]):
-    """ Sets the parameters for a kernel node in the given graphExec.
+def cudaGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled):
+    """ Enables or disables the specified node in the given graphExec.
 
-    Sets the parameters of a kernel node in an executable graph
-    `hGraphExec`. The node is identified by the corresponding node `node`
-    in the non-executable graph, from which the executable graph was
-    instantiated.
+    Sets `hNode` to be either enabled or disabled. Disabled nodes are
+    functionally equivalent to empty nodes until they are reenabled.
+    Existing node parameters are not affected by disabling/enabling the
+    node.
 
-    `node` must not have been removed from the original graph. The `func`
-    field of `nodeParams` cannot be modified and must match the original
-    value. All other values can be modified.
+    The node is identified by the corresponding node `hNode` in the non-
+    executable graph, from which the executable graph was instantiated.
+
+    `hNode` must not have been removed from the original graph.
 
     The modifications only affect future launches of `hGraphExec`. Already
     enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+    call. `hNode` is also not modified by this call.
 
     Parameters
     ----------
     hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
         The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        kernel node from the graph from which graphExec was instantiated
-    pNodeParams : :py:obj:`~.cudaKernelNodeParams`
-        Updated Parameters to set
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node from the graph from which graphExec was instantiated
+    isEnabled : unsigned int
+        Node is enabled if != 0, otherwise the node is disabled
 
     Returns
     -------
@@ -24448,208 +24835,258 @@ def cudaGraphExecKernelNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddKernelNode`, :py:obj:`~.cudaGraphKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphNodeGetEnabled`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate` :py:obj:`~.cudaGraphLaunch`
+
+    Notes
+    -----
+    Currently only kernel, memset and memcpy nodes are supported.
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     else:
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef ccudart.cudaKernelNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphExecKernelNodeSetParams(chGraphExec, cnode, cpNodeParams_ptr)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    err = cyruntime.cudaGraphNodeSetEnabled(cyhGraphExec, cyhNode, isEnabled)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecMemcpyNodeSetParams' in found_functions}}
+{{if 'cudaGraphNodeGetEnabled' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecMemcpyNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemcpy3DParms]):
-    """ Sets the parameters for a memcpy node in the given graphExec.
-
-    Updates the work represented by `node` in `hGraphExec` as though `node`
-    had contained `pNodeParams` at instantiation. `node` must remain in the
-    graph which was used to instantiate `hGraphExec`. Changed edges to and
-    from `node` are ignored.
-
-    The source and destination memory in `pNodeParams` must be allocated
-    from the same contexts as the original source and destination memory.
-    Both the instantiation-time memory operands and the memory operands in
-    `pNodeParams` must be 1-dimensional. Zero-length operations are not
-    supported.
+def cudaGraphNodeGetEnabled(hGraphExec, hNode):
+    """ Query whether a node in the given graphExec is enabled.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+    Sets isEnabled to 1 if `hNode` is enabled, or 0 if `hNode` is disabled.
 
-    Returns :py:obj:`~.cudaErrorInvalidValue` if the memory operands'
-    mappings changed or either the original or new memory operands are
-    multidimensional.
+    The node is identified by the corresponding node `hNode` in the non-
+    executable graph, from which the executable graph was instantiated.
+
+    `hNode` must not have been removed from the original graph.
 
     Parameters
     ----------
     hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
         The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Memcpy node from the graph which was used to instantiate graphExec
-    pNodeParams : :py:obj:`~.cudaMemcpy3DParms`
-        Updated Parameters to set
+    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
+        Node from the graph from which graphExec was instantiated
 
     Returns
     -------
     cudaError_t
         :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+    isEnabled : unsigned int
+        Location to return the enabled status of the node
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParamsToSymbol`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParamsFromSymbol`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphNodeSetEnabled`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate` :py:obj:`~.cudaGraphLaunch`
+
+    Notes
+    -----
+    Currently only kernel, memset and memcpy nodes are supported.
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraphNode_t cyhNode
+    if hNode is None:
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>0
+    elif isinstance(hNode, (cudaGraphNode_t,driver.CUgraphNode)):
+        phNode = int(hNode)
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
+        phNode = int(cudaGraphNode_t(hNode))
+        cyhNode = <cyruntime.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     else:
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef ccudart.cudaMemcpy3DParms* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphExecMemcpyNodeSetParams(chGraphExec, cnode, cpNodeParams_ptr)
-    return (cudaError_t(err),)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef unsigned int isEnabled = 0
+    err = cyruntime.cudaGraphNodeGetEnabled(cyhGraphExec, cyhNode, &isEnabled)
+    return (cudaError_t(err), isEnabled)
 {{endif}}
 
-{{if 'cudaGraphExecMemcpyNodeSetParams1D' in found_functions}}
+{{if 'cudaGraphExecUpdate' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecMemcpyNodeSetParams1D(hGraphExec, node, dst, src, size_t count, kind not None : cudaMemcpyKind):
-    """ Sets the parameters for a memcpy node in the given graphExec to perform a 1-dimensional copy.
+def cudaGraphExecUpdate(hGraphExec, hGraph):
+    """ Check whether an executable graph can be updated with a graph and perform the update if possible.
 
-    Updates the work represented by `node` in `hGraphExec` as though `node`
-    had contained the given params at instantiation. `node` must remain in
-    the graph which was used to instantiate `hGraphExec`. Changed edges to
-    and from `node` are ignored.
+    Updates the node parameters in the instantiated graph specified by
+    `hGraphExec` with the node parameters in a topologically identical
+    graph specified by `hGraph`.
 
-    `src` and `dst` must be allocated from the same contexts as the
-    original source and destination memory. The instantiation-time memory
-    operands must be 1-dimensional. Zero-length operations are not
-    supported.
+    Limitations:
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+    - Kernel nodes:
 
-    Returns :py:obj:`~.cudaErrorInvalidValue` if the memory operands'
-    mappings changed or the original memory operands are multidimensional.
+      - The owning context of the function cannot change.
+
+      - A node whose function originally did not use CUDA dynamic
+        parallelism cannot be updated to a function which uses CDP.
+
+      - A cooperative node cannot be updated to a non-cooperative node, and
+        vice-versa.
+
+      - If the graph was instantiated with
+        cudaGraphInstantiateFlagUseNodePriority, the priority attribute
+        cannot change. Equality is checked on the originally requested
+        priority values, before they are clamped to the device's supported
+        range.
+
+    - Memset and memcpy nodes:
+
+      - The CUDA device(s) to which the operand(s) was allocated/mapped
+        cannot change.
+
+      - The source/destination memory must be allocated from the same
+        contexts as the original source/destination memory.
+
+      - Only 1D memsets can be changed.
+
+    - Additional memcpy node restrictions:
+
+      - Changing either the source or destination memory type(i.e.
+        CU_MEMORYTYPE_DEVICE, CU_MEMORYTYPE_ARRAY, etc.) is not supported.
+
+    Note: The API may add further restrictions in future releases. The
+    return code should always be checked.
+
+    cudaGraphExecUpdate sets `updateResult_out` to
+    cudaGraphExecUpdateErrorTopologyChanged under the following conditions:
+
+    - The count of nodes directly in `hGraphExec` and `hGraph` differ, in
+      which case `hErrorNode_out` is NULL.
+
+    - A node is deleted in `hGraph` but not not its pair from `hGraphExec`,
+      in which case `hErrorNode_out` is NULL.
+
+    - A node is deleted in `hGraphExec` but not its pair from `hGraph`, in
+      which case `hErrorNode_out` is the pairless node from `hGraph`.
+
+    - The dependent nodes of a pair differ, in which case `hErrorNode_out`
+      is the node from `hGraph`.
+
+    cudaGraphExecUpdate sets `updateResult_out` to:
+
+    - cudaGraphExecUpdateError if passed an invalid value.
+
+    - cudaGraphExecUpdateErrorTopologyChanged if the graph topology changed
+
+    - cudaGraphExecUpdateErrorNodeTypeChanged if the type of a node
+      changed, in which case `hErrorNode_out` is set to the node from
+      `hGraph`.
+
+    - cudaGraphExecUpdateErrorFunctionChanged if the function of a kernel
+      node changed (CUDA driver < 11.2)
+
+    - cudaGraphExecUpdateErrorUnsupportedFunctionChange if the func field
+      of a kernel changed in an unsupported way(see note above), in which
+      case `hErrorNode_out` is set to the node from `hGraph`
+
+    - cudaGraphExecUpdateErrorParametersChanged if any parameters to a node
+      changed in a way that is not supported, in which case
+      `hErrorNode_out` is set to the node from `hGraph`
+
+    - cudaGraphExecUpdateErrorAttributesChanged if any attributes of a node
+      changed in a way that is not supported, in which case
+      `hErrorNode_out` is set to the node from `hGraph`
+
+    - cudaGraphExecUpdateErrorNotSupported if something about a node is
+      unsupported, like the node's type or configuration, in which case
+      `hErrorNode_out` is set to the node from `hGraph`
+
+    If `updateResult_out` isn't set in one of the situations described
+    above, the update check passes and cudaGraphExecUpdate updates
+    `hGraphExec` to match the contents of `hGraph`. If an error happens
+    during the update, `updateResult_out` will be set to
+    cudaGraphExecUpdateError; otherwise, `updateResult_out` is set to
+    cudaGraphExecUpdateSuccess.
+
+    cudaGraphExecUpdate returns cudaSuccess when the updated was performed
+    successfully. It returns cudaErrorGraphExecUpdateFailure if the graph
+    update was not performed because it included changes which violated
+    constraints specific to instantiated graph update.
 
     Parameters
     ----------
     hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Memcpy node from the graph which was used to instantiate graphExec
-    dst : Any
-        Destination memory address
-    src : Any
-        Source memory address
-    count : size_t
-        Size in bytes to copy
-    kind : :py:obj:`~.cudaMemcpyKind`
-        Type of transfer
+        The instantiated graph to be updated
+    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph containing the updated parameters
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorGraphExecUpdateFailure`,
+    hErrorNode_out : :py:obj:`~.cudaGraphNode_t`
+        The node which caused the permissibility check to forbid the
+        update, if any
+    updateResult_out : :py:obj:`~.cudaGraphExecUpdateResult`
+        Whether the graph update was permitted. If was forbidden, the
+        reason why
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemcpyNode`, :py:obj:`~.cudaGraphAddMemcpyNode1D`, :py:obj:`~.cudaGraphMemcpyNodeSetParams`, :py:obj:`~.cudaGraphMemcpyNodeSetParams1D`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphInstantiate`,
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaGraph_t cyhGraph
+    if hGraph is None:
+        cyhGraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(hGraph, (cudaGraph_t,driver.CUgraph)):
+        phGraph = int(hGraph)
+        cyhGraph = <cyruntime.cudaGraph_t><void_ptr>phGraph
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
+        phGraph = int(cudaGraph_t(hGraph))
+        cyhGraph = <cyruntime.cudaGraph_t><void_ptr>phGraph
+    cdef cyruntime.cudaGraphExec_t cyhGraphExec
     if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(hGraphExec, (cudaGraphExec_t,driver.CUgraphExec)):
         phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
     else:
         phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdst = utils.HelperInputVoidPtr(dst)
-    cdef void* cdst_ptr = <void*><void_ptr>cdst.cptr
-    csrc = utils.HelperInputVoidPtr(src)
-    cdef void* csrc_ptr = <void*><void_ptr>csrc.cptr
-    cdef ccudart.cudaMemcpyKind ckind = kind.value
-    err = ccudart.cudaGraphExecMemcpyNodeSetParams1D(chGraphExec, cnode, cdst_ptr, csrc_ptr, count, ckind)
-    return (cudaError_t(err),)
+        cyhGraphExec = <cyruntime.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cudaGraphNode_t hErrorNode_out = cudaGraphNode_t()
+    cdef cyruntime.cudaGraphExecUpdateResult updateResult_out
+    err = cyruntime.cudaGraphExecUpdate(cyhGraphExec, cyhGraph, <cyruntime.cudaGraphNode_t*>hErrorNode_out._ptr, &updateResult_out)
+    return (cudaError_t(err), hErrorNode_out, cudaGraphExecUpdateResult(updateResult_out))
 {{endif}}
 
-{{if 'cudaGraphExecMemsetNodeSetParams' in found_functions}}
+{{if 'cudaGraphUpload' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaMemsetParams]):
-    """ Sets the parameters for a memset node in the given graphExec.
-
-    Updates the work represented by `node` in `hGraphExec` as though `node`
-    had contained `pNodeParams` at instantiation. `node` must remain in the
-    graph which was used to instantiate `hGraphExec`. Changed edges to and
-    from `node` are ignored.
-
-    The destination memory in `pNodeParams` must be allocated from the same
-    context as the original destination memory. Both the instantiation-time
-    memory operand and the memory operand in `pNodeParams` must be
-    1-dimensional. Zero-length operations are not supported.
-
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+def cudaGraphUpload(graphExec, stream):
+    """ Uploads an executable graph in a stream.
 
-    Returns cudaErrorInvalidValue if the memory operand's mappings changed
-    or either the original or new memory operand are multidimensional.
+    Uploads `hGraphExec` to the device in `hStream` without executing it.
+    Uploads of the same `hGraphExec` will be serialized. Each upload is
+    ordered behind both any previous work in `hStream` and any previous
+    launches of `hGraphExec`. Uses memory cached by `stream` to back the
+    allocations owned by `graphExec`.
 
     Parameters
     ----------
     hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Memset node from the graph which was used to instantiate graphExec
-    pNodeParams : :py:obj:`~.cudaMemsetParams`
-        Updated Parameters to set
+        Executable graph to upload
+    hStream : :py:obj:`~.CUstream` or :py:obj:`~.cudaStream_t`
+        Stream in which to upload the graph
 
     Returns
     -------
@@ -24658,1386 +25095,1284 @@ def cudaGraphExecMemsetNodeSetParams(hGraphExec, node, pNodeParams : Optional[cu
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddMemsetNode`, :py:obj:`~.cudaGraphMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaStream_t cystream
+    if stream is None:
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
+        pstream = int(stream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        pstream = int(cudaStream_t(stream))
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaGraphExec_t cygraphExec
+    if graphExec is None:
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(graphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        pgraphExec = int(graphExec)
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef ccudart.cudaMemsetParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphExecMemsetNodeSetParams(chGraphExec, cnode, cpNodeParams_ptr)
+        pgraphExec = int(cudaGraphExec_t(graphExec))
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
+    err = cyruntime.cudaGraphUpload(cygraphExec, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecHostNodeSetParams' in found_functions}}
+{{if 'cudaGraphLaunch' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecHostNodeSetParams(hGraphExec, node, pNodeParams : Optional[cudaHostNodeParams]):
-    """ Sets the parameters for a host node in the given graphExec.
+def cudaGraphLaunch(graphExec, stream):
+    """ Launches an executable graph in a stream.
 
-    Updates the work represented by `node` in `hGraphExec` as though `node`
-    had contained `pNodeParams` at instantiation. `node` must remain in the
-    graph which was used to instantiate `hGraphExec`. Changed edges to and
-    from `node` are ignored.
+    Executes `graphExec` in `stream`. Only one instance of `graphExec` may
+    be executing at a time. Each launch is ordered behind both any previous
+    work in `stream` and any previous launches of `graphExec`. To execute a
+    graph concurrently, it must be instantiated multiple times into
+    multiple executable graphs.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+    If any allocations created by `graphExec` remain unfreed (from a
+    previous launch) and `graphExec` was not instantiated with
+    :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`, the launch will
+    fail with :py:obj:`~.cudaErrorInvalidValue`.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Host node from the graph which was used to instantiate graphExec
-    pNodeParams : :py:obj:`~.cudaHostNodeParams`
-        Updated Parameters to set
+    graphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        Executable graph to launch
+    stream : :py:obj:`~.CUstream` or :py:obj:`~.cudaStream_t`
+        Stream in which to launch the graph
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddHostNode`, :py:obj:`~.cudaGraphHostNodeSetParams`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphExecDestroy`
     """
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
+    cdef cyruntime.cudaStream_t cystream
+    if stream is None:
+        cystream = <cyruntime.cudaStream_t><void_ptr>0
+    elif isinstance(stream, (cudaStream_t,driver.CUstream)):
+        pstream = int(stream)
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
     else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        pstream = int(cudaStream_t(stream))
+        cystream = <cyruntime.cudaStream_t><void_ptr>pstream
+    cdef cyruntime.cudaGraphExec_t cygraphExec
+    if graphExec is None:
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(graphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        pgraphExec = int(graphExec)
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef ccudart.cudaHostNodeParams* cpNodeParams_ptr = pNodeParams._ptr if pNodeParams != None else NULL
-    err = ccudart.cudaGraphExecHostNodeSetParams(chGraphExec, cnode, cpNodeParams_ptr)
+        pgraphExec = int(cudaGraphExec_t(graphExec))
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
+    err = cyruntime.cudaGraphLaunch(cygraphExec, cystream)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecChildGraphNodeSetParams' in found_functions}}
+{{if 'cudaGraphExecDestroy' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecChildGraphNodeSetParams(hGraphExec, node, childGraph):
-    """ Updates node parameters in the child graph node in the given graphExec.
-
-    Updates the work represented by `node` in `hGraphExec` as though the
-    nodes contained in `node's` graph had the parameters contained in
-    `childGraph's` nodes at instantiation. `node` must remain in the graph
-    which was used to instantiate `hGraphExec`. Changed edges to and from
-    `node` are ignored.
-
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `node` is also not modified by this call.
+def cudaGraphExecDestroy(graphExec):
+    """ Destroys an executable graph.
 
-    The topology of `childGraph`, as well as the node insertion order, must
-    match that of the graph contained in `node`. See
-    :py:obj:`~.cudaGraphExecUpdate()` for a list of restrictions on what
-    can be updated in an instantiated graph. The update is recursive, so
-    child graph nodes contained within the top level child graph will also
-    be updated.
+    Destroys the executable graph specified by `graphExec`.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    node : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Host node from the graph which was used to instantiate graphExec
-    childGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph supplying the updated parameters
+    graphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
+        Executable graph to destroy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddChildGraphNode`, :py:obj:`~.cudaGraphChildGraphNodeGetGraph`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`
     """
-    cdef ccudart.cudaGraph_t cchildGraph
-    if childGraph is None:
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(childGraph, (cudaGraph_t,cuda.CUgraph)):
-        pchildGraph = int(childGraph)
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>pchildGraph
-    else:
-        pchildGraph = int(cudaGraph_t(childGraph))
-        cchildGraph = <ccudart.cudaGraph_t><void_ptr>pchildGraph
-
-    cdef ccudart.cudaGraphNode_t cnode
-    if node is None:
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(node, (cudaGraphNode_t,cuda.CUgraphNode)):
-        pnode = int(node)
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-    else:
-        pnode = int(cudaGraphNode_t(node))
-        cnode = <ccudart.cudaGraphNode_t><void_ptr>pnode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaGraphExec_t cygraphExec
+    if graphExec is None:
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>0
+    elif isinstance(graphExec, (cudaGraphExec_t,driver.CUgraphExec)):
+        pgraphExec = int(graphExec)
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    err = ccudart.cudaGraphExecChildGraphNodeSetParams(chGraphExec, cnode, cchildGraph)
+        pgraphExec = int(cudaGraphExec_t(graphExec))
+        cygraphExec = <cyruntime.cudaGraphExec_t><void_ptr>pgraphExec
+    err = cyruntime.cudaGraphExecDestroy(cygraphExec)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecEventRecordNodeSetEvent' in found_functions}}
+{{if 'cudaGraphDestroy' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecEventRecordNodeSetEvent(hGraphExec, hNode, event):
-    """ Sets the event for an event record node in the given graphExec.
-
-    Sets the event of an event record node in an executable graph
-    `hGraphExec`. The node is identified by the corresponding node `hNode`
-    in the non-executable graph, from which the executable graph was
-    instantiated.
+def cudaGraphDestroy(graph):
+    """ Destroys a graph.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `hNode` is also not modified by this call.
+    Destroys the graph specified by `graph`, as well as all of its nodes.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Event record node from the graph from which graphExec was
-        instantiated
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Updated event to use
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        Graph to destroy
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddEventRecordNode`, :py:obj:`~.cudaGraphEventRecordNodeGetEvent`, :py:obj:`~.cudaGraphEventWaitNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaGraphCreate`
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-    else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    err = ccudart.cudaGraphExecEventRecordNodeSetEvent(chGraphExec, chNode, cevent)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    err = cyruntime.cudaGraphDestroy(cygraph)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecEventWaitNodeSetEvent' in found_functions}}
+{{if 'cudaGraphDebugDotPrint' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecEventWaitNodeSetEvent(hGraphExec, hNode, event):
-    """ Sets the event for an event wait node in the given graphExec.
-
-    Sets the event of an event wait node in an executable graph
-    `hGraphExec`. The node is identified by the corresponding node `hNode`
-    in the non-executable graph, from which the executable graph was
-    instantiated.
+def cudaGraphDebugDotPrint(graph, char* path, unsigned int flags):
+    """ Write a DOT file describing graph structure.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `hNode` is also not modified by this call.
+    Using the provided `graph`, write to `path` a DOT formatted description
+    of the graph. By default this includes the graph topology, node types,
+    node id, kernel names and memcpy direction. `flags` can be specified to
+    write more detailed information about each node type such as parameter
+    values, kernel attributes, node and function handles.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Event wait node from the graph from which graphExec was
-        instantiated
-    event : :py:obj:`~.CUevent` or :py:obj:`~.cudaEvent_t`
-        Updated event to use
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph to create a DOT file from
+    path : bytes
+        The path to write the DOT file to
+    flags : unsigned int
+        Flags from cudaGraphDebugDotFlags for specifying which additional
+        node information to write
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
-
-    See Also
-    --------
-    :py:obj:`~.cudaGraphAddEventWaitNode`, :py:obj:`~.cudaGraphEventWaitNodeGetEvent`, :py:obj:`~.cudaGraphEventRecordNodeSetEvent`, :py:obj:`~.cudaEventRecordWithFlags`, :py:obj:`~.cudaStreamWaitEvent`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOperatingSystem`
     """
-    cdef ccudart.cudaEvent_t cevent
-    if event is None:
-        cevent = <ccudart.cudaEvent_t><void_ptr>0
-    elif isinstance(event, (cudaEvent_t,cuda.CUevent)):
-        pevent = int(event)
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-    else:
-        pevent = int(cudaEvent_t(event))
-        cevent = <ccudart.cudaEvent_t><void_ptr>pevent
-
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-    else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    err = ccudart.cudaGraphExecEventWaitNodeSetEvent(chGraphExec, chNode, cevent)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    err = cyruntime.cudaGraphDebugDotPrint(cygraph, path, flags)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecExternalSemaphoresSignalNodeSetParams' in found_functions}}
+{{if 'cudaUserObjectCreate' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecExternalSemaphoresSignalNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreSignalNodeParams]):
-    """ Sets the parameters for an external semaphore signal node in the given graphExec.
-
-    Sets the parameters of an external semaphore signal node in an
-    executable graph `hGraphExec`. The node is identified by the
-    corresponding node `hNode` in the non-executable graph, from which the
-    executable graph was instantiated.
+def cudaUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned int flags):
+    """ Create a user object.
 
-    `hNode` must not have been removed from the original graph.
+    Create a user object with the specified destructor callback and initial
+    reference count. The initial references are owned by the caller.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `hNode` is also not modified by this call.
+    Destructor callbacks cannot make CUDA API calls and should avoid
+    blocking behavior, as they are executed by a shared internal thread.
+    Another thread may be signaled to perform such actions, if it does not
+    block forward progress of tasks scheduled through CUDA.
 
-    Changing `nodeParams->numExtSems` is not supported.
+    See CUDA User Objects in the CUDA C++ Programming Guide for more
+    information on user objects.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        semaphore signal node from the graph from which graphExec was
-        instantiated
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreSignalNodeParams`
-        Updated Parameters to set
+    ptr : Any
+        The pointer to pass to the destroy function
+    destroy : :py:obj:`~.cudaHostFn_t`
+        Callback to free the user object when it is no longer in use
+    initialRefcount : unsigned int
+        The initial refcount to create the object with, typically 1. The
+        initial references are owned by the calling thread.
+    flags : unsigned int
+        Currently it is required to pass
+        :py:obj:`~.cudaUserObjectNoDestructorSync`, which is the only
+        defined flag. This indicates that the destroy callback cannot be
+        waited on by any CUDA API. Users requiring synchronization of the
+        callback should signal its completion manually.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    object_out : :py:obj:`~.cudaUserObject_t`
+        Location to return the user object handle
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddExternalSemaphoresSignalNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresWaitNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaHostFn_t cydestroy
+    if destroy is None:
+        cydestroy = <cyruntime.cudaHostFn_t><void_ptr>0
+    elif isinstance(destroy, (cudaHostFn_t,)):
+        pdestroy = int(destroy)
+        cydestroy = <cyruntime.cudaHostFn_t><void_ptr>pdestroy
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+        pdestroy = int(cudaHostFn_t(destroy))
+        cydestroy = <cyruntime.cudaHostFn_t><void_ptr>pdestroy
+    cdef cudaUserObject_t object_out = cudaUserObject_t()
+    cyptr = utils.HelperInputVoidPtr(ptr)
+    cdef void* cyptr_ptr = <void*><void_ptr>cyptr.cptr
+    err = cyruntime.cudaUserObjectCreate(<cyruntime.cudaUserObject_t*>object_out._ptr, cyptr_ptr, cydestroy, initialRefcount, flags)
+    return (cudaError_t(err), object_out)
+{{endif}}
 
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-    else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+{{if 'cudaUserObjectRetain' in found_functions}}
+
+@cython.embedsignature(True)
+def cudaUserObjectRetain(object, unsigned int count):
+    """ Retain a reference to a user object.
+
+    Retains new references to a user object. The new references are owned
+    by the caller.
+
+    See CUDA User Objects in the CUDA C++ Programming Guide for more
+    information on user objects.
+
+    Parameters
+    ----------
+    object : :py:obj:`~.cudaUserObject_t`
+        The object to retain
+    count : unsigned int
+        The number of references to retain, typically 1. Must be nonzero
+        and not larger than INT_MAX.
+
+    Returns
+    -------
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
-    cdef ccudart.cudaExternalSemaphoreSignalNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphExecExternalSemaphoresSignalNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+    See Also
+    --------
+    :py:obj:`~.cudaUserObjectCreate`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
+    """
+    cdef cyruntime.cudaUserObject_t cyobject
+    if object is None:
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>0
+    elif isinstance(object, (cudaUserObject_t,driver.CUuserObject)):
+        pobject = int(object)
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
+    else:
+        pobject = int(cudaUserObject_t(object))
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
+    err = cyruntime.cudaUserObjectRetain(cyobject, count)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecExternalSemaphoresWaitNodeSetParams' in found_functions}}
+{{if 'cudaUserObjectRelease' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecExternalSemaphoresWaitNodeSetParams(hGraphExec, hNode, nodeParams : Optional[cudaExternalSemaphoreWaitNodeParams]):
-    """ Sets the parameters for an external semaphore wait node in the given graphExec.
-
-    Sets the parameters of an external semaphore wait node in an executable
-    graph `hGraphExec`. The node is identified by the corresponding node
-    `hNode` in the non-executable graph, from which the executable graph
-    was instantiated.
+def cudaUserObjectRelease(object, unsigned int count):
+    """ Release a reference to a user object.
 
-    `hNode` must not have been removed from the original graph.
+    Releases user object references owned by the caller. The object's
+    destructor is invoked if the reference count reaches zero.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `hNode` is also not modified by this call.
+    It is undefined behavior to release references not owned by the caller,
+    or to use a user object handle after all references are released.
 
-    Changing `nodeParams->numExtSems` is not supported.
+    See CUDA User Objects in the CUDA C++ Programming Guide for more
+    information on user objects.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        semaphore wait node from the graph from which graphExec was
-        instantiated
-    nodeParams : :py:obj:`~.cudaExternalSemaphoreWaitNodeParams`
-        Updated Parameters to set
+    object : :py:obj:`~.cudaUserObject_t`
+        The object to release
+    count : unsigned int
+        The number of references to release, typically 1. Must be nonzero
+        and not larger than INT_MAX.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphAddExternalSemaphoresWaitNode`, :py:obj:`~.cudaImportExternalSemaphore`, :py:obj:`~.cudaSignalExternalSemaphoresAsync`, :py:obj:`~.cudaWaitExternalSemaphoresAsync`, :py:obj:`~.cudaGraphExecKernelNodeSetParams`, :py:obj:`~.cudaGraphExecMemcpyNodeSetParams`, :py:obj:`~.cudaGraphExecMemsetNodeSetParams`, :py:obj:`~.cudaGraphExecHostNodeSetParams`, :py:obj:`~.cudaGraphExecChildGraphNodeSetParams`, :py:obj:`~.cudaGraphExecEventRecordNodeSetEvent`, :py:obj:`~.cudaGraphExecEventWaitNodeSetEvent`, :py:obj:`~.cudaGraphExecExternalSemaphoresSignalNodeSetParams`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate`
+    :py:obj:`~.cudaUserObjectCreate`, :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-    else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+    cdef cyruntime.cudaUserObject_t cyobject
+    if object is None:
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>0
+    elif isinstance(object, (cudaUserObject_t,driver.CUuserObject)):
+        pobject = int(object)
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef ccudart.cudaExternalSemaphoreWaitNodeParams* cnodeParams_ptr = nodeParams._ptr if nodeParams != None else NULL
-    err = ccudart.cudaGraphExecExternalSemaphoresWaitNodeSetParams(chGraphExec, chNode, cnodeParams_ptr)
+        pobject = int(cudaUserObject_t(object))
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
+    err = cyruntime.cudaUserObjectRelease(cyobject, count)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphNodeSetEnabled' in found_functions}}
+{{if 'cudaGraphRetainUserObject' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphNodeSetEnabled(hGraphExec, hNode, unsigned int isEnabled):
-    """ Enables or disables the specified node in the given graphExec.
-
-    Sets `hNode` to be either enabled or disabled. Disabled nodes are
-    functionally equivalent to empty nodes until they are reenabled.
-    Existing node parameters are not affected by disabling/enabling the
-    node.
-
-    The node is identified by the corresponding node `hNode` in the non-
-    executable graph, from which the executable graph was instantiated.
+def cudaGraphRetainUserObject(graph, object, unsigned int count, unsigned int flags):
+    """ Retain a reference to a user object from a graph.
 
-    `hNode` must not have been removed from the original graph.
+    Creates or moves user object references that will be owned by a CUDA
+    graph.
 
-    The modifications only affect future launches of `hGraphExec`. Already
-    enqueued or running launches of `hGraphExec` are not affected by this
-    call. `hNode` is also not modified by this call.
+    See CUDA User Objects in the CUDA C++ Programming Guide for more
+    information on user objects.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node from the graph from which graphExec was instantiated
-    isEnabled : unsigned int
-        Node is enabled if != 0, otherwise the node is disabled
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph to associate the reference with
+    object : :py:obj:`~.cudaUserObject_t`
+        The user object to retain a reference for
+    count : unsigned int
+        The number of references to add to the graph, typically 1. Must be
+        nonzero and not larger than INT_MAX.
+    flags : unsigned int
+        The optional flag :py:obj:`~.cudaGraphUserObjectMove` transfers
+        references from the calling thread, rather than create new
+        references. Pass 0 to create new references.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphNodeGetEnabled`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate` :py:obj:`~.cudaGraphLaunch`
-
-    Notes
-    -----
-    Currently only kernel, memset and memcpy nodes are supported.
+    :py:obj:`~.cudaUserObjectCreate` :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaUserObject_t cyobject
+    if object is None:
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>0
+    elif isinstance(object, (cudaUserObject_t,driver.CUuserObject)):
+        pobject = int(object)
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        pobject = int(cudaUserObject_t(object))
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    err = ccudart.cudaGraphNodeSetEnabled(chGraphExec, chNode, isEnabled)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    err = cyruntime.cudaGraphRetainUserObject(cygraph, cyobject, count, flags)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphNodeGetEnabled' in found_functions}}
+{{if 'cudaGraphReleaseUserObject' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphNodeGetEnabled(hGraphExec, hNode):
-    """ Query whether a node in the given graphExec is enabled.
-
-    Sets isEnabled to 1 if `hNode` is enabled, or 0 if `hNode` is disabled.
+def cudaGraphReleaseUserObject(graph, object, unsigned int count):
+    """ Release a user object reference from a graph.
 
-    The node is identified by the corresponding node `hNode` in the non-
-    executable graph, from which the executable graph was instantiated.
+    Releases user object references owned by a graph.
 
-    `hNode` must not have been removed from the original graph.
+    See CUDA User Objects in the CUDA C++ Programming Guide for more
+    information on user objects.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The executable graph in which to set the specified node
-    hNode : :py:obj:`~.CUgraphNode` or :py:obj:`~.cudaGraphNode_t`
-        Node from the graph from which graphExec was instantiated
+    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
+        The graph that will release the reference
+    object : :py:obj:`~.cudaUserObject_t`
+        The user object to release a reference for
+    count : unsigned int
+        The number of references to release, typically 1. Must be nonzero
+        and not larger than INT_MAX.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
-    isEnabled : unsigned int
-        Location to return the enabled status of the node
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphNodeSetEnabled`, :py:obj:`~.cudaGraphExecUpdate`, :py:obj:`~.cudaGraphInstantiate` :py:obj:`~.cudaGraphLaunch`
-
-    Notes
-    -----
-    Currently only kernel, memset and memcpy nodes are supported.
+    :py:obj:`~.cudaUserObjectCreate` :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphCreate`
     """
-    cdef ccudart.cudaGraphNode_t chNode
-    if hNode is None:
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>0
-    elif isinstance(hNode, (cudaGraphNode_t,cuda.CUgraphNode)):
-        phNode = int(hNode)
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
+    cdef cyruntime.cudaUserObject_t cyobject
+    if object is None:
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>0
+    elif isinstance(object, (cudaUserObject_t,driver.CUuserObject)):
+        pobject = int(object)
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
     else:
-        phNode = int(cudaGraphNode_t(hNode))
-        chNode = <ccudart.cudaGraphNode_t><void_ptr>phNode
-
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+        pobject = int(cudaUserObject_t(object))
+        cyobject = <cyruntime.cudaUserObject_t><void_ptr>pobject
+    cdef cyruntime.cudaGraph_t cygraph
+    if graph is None:
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>0
+    elif isinstance(graph, (cudaGraph_t,driver.CUgraph)):
+        pgraph = int(graph)
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
     else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-
-    cdef unsigned int isEnabled = 0
-    err = ccudart.cudaGraphNodeGetEnabled(chGraphExec, chNode, &isEnabled)
-    return (cudaError_t(err), isEnabled)
+        pgraph = int(cudaGraph_t(graph))
+        cygraph = <cyruntime.cudaGraph_t><void_ptr>pgraph
+    err = cyruntime.cudaGraphReleaseUserObject(cygraph, cyobject, count)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphExecUpdate' in found_functions}}
+{{if 'cudaGetDriverEntryPoint' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphExecUpdate(hGraphExec, hGraph):
-    """ Check whether an executable graph can be updated with a graph and perform the update if possible.
-
-    Updates the node parameters in the instantiated graph specified by
-    `hGraphExec` with the node parameters in a topologically identical
-    graph specified by `hGraph`.
-
-    Limitations:
-
-    - Kernel nodes:
-
-      - The owning context of the function cannot change.
-
-      - A node whose function originally did not use CUDA dynamic
-        parallelism cannot be updated to a function which uses CDP.
-
-      - A cooperative node cannot be updated to a non-cooperative node, and
-        vice-versa.
-
-      - If the graph was instantiated with
-        cudaGraphInstantiateFlagUseNodePriority, the priority attribute
-        cannot change. Equality is checked on the originally requested
-        priority values, before they are clamped to the device's supported
-        range.
-
-    - Memset and memcpy nodes:
-
-      - The CUDA device(s) to which the operand(s) was allocated/mapped
-        cannot change.
-
-      - The source/destination memory must be allocated from the same
-        contexts as the original source/destination memory.
-
-      - Only 1D memsets can be changed.
-
-    - Additional memcpy node restrictions:
-
-      - Changing either the source or destination memory type(i.e.
-        CU_MEMORYTYPE_DEVICE, CU_MEMORYTYPE_ARRAY, etc.) is not supported.
-
-    Note: The API may add further restrictions in future releases. The
-    return code should always be checked.
-
-    cudaGraphExecUpdate sets `updateResult_out` to
-    cudaGraphExecUpdateErrorTopologyChanged under the following conditions:
-
-    - The count of nodes directly in `hGraphExec` and `hGraph` differ, in
-      which case `hErrorNode_out` is NULL.
-
-    - A node is deleted in `hGraph` but not not its pair from `hGraphExec`,
-      in which case `hErrorNode_out` is NULL.
-
-    - A node is deleted in `hGraphExec` but not its pair from `hGraph`, in
-      which case `hErrorNode_out` is the pairless node from `hGraph`.
-
-    - The dependent nodes of a pair differ, in which case `hErrorNode_out`
-      is the node from `hGraph`.
-
-    cudaGraphExecUpdate sets `updateResult_out` to:
-
-    - cudaGraphExecUpdateError if passed an invalid value.
-
-    - cudaGraphExecUpdateErrorTopologyChanged if the graph topology changed
+def cudaGetDriverEntryPoint(char* symbol, unsigned long long flags):
+    """ Returns the requested driver API function pointer.
 
-    - cudaGraphExecUpdateErrorNodeTypeChanged if the type of a node
-      changed, in which case `hErrorNode_out` is set to the node from
-      `hGraph`.
+    Returns in `**funcPtr` the address of the CUDA driver function for the
+    requested flags.
 
-    - cudaGraphExecUpdateErrorFunctionChanged if the function of a kernel
-      node changed (CUDA driver < 11.2)
+    For a requested driver symbol, if the CUDA version in which the driver
+    symbol was introduced is less than or equal to the CUDA runtime
+    version, the API will return the function pointer to the corresponding
+    versioned driver function.
 
-    - cudaGraphExecUpdateErrorUnsupportedFunctionChange if the func field
-      of a kernel changed in an unsupported way(see note above), in which
-      case `hErrorNode_out` is set to the node from `hGraph`
+    The pointer returned by the API should be cast to a function pointer
+    matching the requested driver function's definition in the API header
+    file. The function pointer typedef can be picked up from the
+    corresponding typedefs header file. For example, cudaTypedefs.h
+    consists of function pointer typedefs for driver APIs defined in
+    cuda.h.
 
-    - cudaGraphExecUpdateErrorParametersChanged if any parameters to a node
-      changed in a way that is not supported, in which case
-      `hErrorNode_out` is set to the node from `hGraph`
+    The API will return :py:obj:`~.cudaErrorSymbolNotFound` if the
+    requested driver function is not supported on the platform, no ABI
+    compatible driver function exists for the CUDA runtime version or if
+    the driver symbol is invalid.
 
-    - cudaGraphExecUpdateErrorAttributesChanged if any attributes of a node
-      changed in a way that is not supported, in which case
-      `hErrorNode_out` is set to the node from `hGraph`
+    The requested flags can be:
 
-    - cudaGraphExecUpdateErrorNotSupported if something about a node is
-      unsupported, like the node's type or configuration, in which case
-      `hErrorNode_out` is set to the node from `hGraph`
+    - :py:obj:`~.cudaEnableDefault`: This is the default mode. This is
+      equivalent to :py:obj:`~.cudaEnablePerThreadDefaultStream` if the
+      code is compiled with --default-stream per-thread compilation flag or
+      the macro CUDA_API_PER_THREAD_DEFAULT_STREAM is defined;
+      :py:obj:`~.cudaEnableLegacyStream` otherwise.
 
-    If `updateResult_out` isn't set in one of the situations described
-    above, the update check passes and cudaGraphExecUpdate updates
-    `hGraphExec` to match the contents of `hGraph`. If an error happens
-    during the update, `updateResult_out` will be set to
-    cudaGraphExecUpdateError; otherwise, `updateResult_out` is set to
-    cudaGraphExecUpdateSuccess.
+    - :py:obj:`~.cudaEnableLegacyStream`: This will enable the search for
+      all driver symbols that match the requested driver symbol name except
+      the corresponding per-thread versions.
 
-    cudaGraphExecUpdate returns cudaSuccess when the updated was performed
-    successfully. It returns cudaErrorGraphExecUpdateFailure if the graph
-    update was not performed because it included changes which violated
-    constraints specific to instantiated graph update.
+    - :py:obj:`~.cudaEnablePerThreadDefaultStream`: This will enable the
+      search for all driver symbols that match the requested driver symbol
+      name including the per-thread versions. If a per-thread version is
+      not found, the API will return the legacy version of the driver
+      function.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        The instantiated graph to be updated
-    hGraph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph containing the updated parameters
+    symbol : bytes
+        The base name of the driver API function to look for. As an
+        example, for the driver API :py:obj:`~.cuMemAlloc_v2`, `symbol`
+        would be cuMemAlloc. Note that the API will use the CUDA runtime
+        version to return the address to the most recent ABI compatible
+        driver symbol, :py:obj:`~.cuMemAlloc` or :py:obj:`~.cuMemAlloc_v2`.
+    flags : unsigned long long
+        Flags to specify search options.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorGraphExecUpdateFailure`,
-    hErrorNode_out : :py:obj:`~.cudaGraphNode_t`
-        The node which caused the permissibility check to forbid the
-        update, if any
-    updateResult_out : :py:obj:`~.cudaGraphExecUpdateResult`
-        Whether the graph update was permitted. If was forbidden, the
-        reason why
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorSymbolNotFound`
+    funcPtr : Any
+        Location to return the function pointer to the requested driver
+        function
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiate`,
+    :py:obj:`~.cuGetProcAddress`
     """
-    cdef ccudart.cudaGraph_t chGraph
-    if hGraph is None:
-        chGraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(hGraph, (cudaGraph_t,cuda.CUgraph)):
-        phGraph = int(hGraph)
-        chGraph = <ccudart.cudaGraph_t><void_ptr>phGraph
-    else:
-        phGraph = int(cudaGraph_t(hGraph))
-        chGraph = <ccudart.cudaGraph_t><void_ptr>phGraph
+    cdef void_ptr funcPtr = 0
+    err = cyruntime.cudaGetDriverEntryPoint(symbol, <void**>&funcPtr, flags)
+    return (cudaError_t(err), funcPtr)
+{{endif}}
 
-    cdef ccudart.cudaGraphExec_t chGraphExec
-    if hGraphExec is None:
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(hGraphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        phGraphExec = int(hGraphExec)
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
-    else:
-        phGraphExec = int(cudaGraphExec_t(hGraphExec))
-        chGraphExec = <ccudart.cudaGraphExec_t><void_ptr>phGraphExec
+{{if 'cudaGetExportTable' in found_functions}}
 
-    cdef cudaGraphNode_t hErrorNode_out = cudaGraphNode_t()
-    cdef ccudart.cudaGraphExecUpdateResult updateResult_out
-    err = ccudart.cudaGraphExecUpdate(chGraphExec, chGraph, <ccudart.cudaGraphNode_t*>hErrorNode_out._ptr, &updateResult_out)
-    return (cudaError_t(err), hErrorNode_out, cudaGraphExecUpdateResult(updateResult_out))
+@cython.embedsignature(True)
+def cudaGetExportTable(pExportTableId : Optional[cudaUUID_t]):
+    """"""
+    cdef void_ptr ppExportTable = 0
+    cdef cyruntime.cudaUUID_t* cypExportTableId_ptr = pExportTableId._ptr if pExportTableId != None else NULL
+    err = cyruntime.cudaGetExportTable(<const void**>&ppExportTable, cypExportTableId_ptr)
+    return (cudaError_t(err), ppExportTable)
 {{endif}}
 
-{{if 'cudaGraphUpload' in found_functions}}
+{{if 'make_cudaPitchedPtr' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphUpload(graphExec, stream):
-    """ Uploads an executable graph in a stream.
+def make_cudaPitchedPtr(d, size_t p, size_t xsz, size_t ysz):
+    """ Returns a :py:obj:`~.cudaPitchedPtr` based on input parameters.
 
-    Uploads `hGraphExec` to the device in `hStream` without executing it.
-    Uploads of the same `hGraphExec` will be serialized. Each upload is
-    ordered behind both any previous work in `hStream` and any previous
-    launches of `hGraphExec`. Uses memory cached by `stream` to back the
-    allocations owned by `graphExec`.
+    Returns a :py:obj:`~.cudaPitchedPtr` based on the specified input
+    parameters `d`, `p`, `xsz`, and `ysz`.
 
     Parameters
     ----------
-    hGraphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        Executable graph to upload
-    hStream : :py:obj:`~.CUstream` or :py:obj:`~.cudaStream_t`
-        Stream in which to upload the graph
+    d : Any
+        Pointer to allocated memory
+    p : size_t
+        Pitch of allocated memory in bytes
+    xsz : size_t
+        Logical width of allocation in elements
+    ysz : size_t
+        Logical height of allocation in elements
 
     Returns
     -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`,
+    cudaError_t.cudaSuccess
+        cudaError_t.cudaSuccess
+    :py:obj:`~.cudaPitchedPtr`
+        :py:obj:`~.cudaPitchedPtr` specified by `d`, `p`, `xsz`, and `ysz`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphLaunch`, :py:obj:`~.cudaGraphExecDestroy`
+    make_cudaExtent, make_cudaPos
     """
-    cdef ccudart.cudaStream_t cstream
-    if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
-        pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-    else:
-        pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-
-    cdef ccudart.cudaGraphExec_t cgraphExec
-    if graphExec is None:
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(graphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        pgraphExec = int(graphExec)
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
-    else:
-        pgraphExec = int(cudaGraphExec_t(graphExec))
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
-
-    err = ccudart.cudaGraphUpload(cgraphExec, cstream)
-    return (cudaError_t(err),)
+    cyd = utils.HelperInputVoidPtr(d)
+    cdef void* cyd_ptr = <void*><void_ptr>cyd.cptr
+    err = cyruntime.make_cudaPitchedPtr(cyd_ptr, p, xsz, ysz)
+    cdef cudaPitchedPtr wrapper = cudaPitchedPtr()
+    wrapper._ptr[0] = err
+    return wrapper
 {{endif}}
 
-{{if 'cudaGraphLaunch' in found_functions}}
+{{if 'make_cudaPos' in found_functions}}
 
 @cython.embedsignature(True)
-def cudaGraphLaunch(graphExec, stream):
-    """ Launches an executable graph in a stream.
-
-    Executes `graphExec` in `stream`. Only one instance of `graphExec` may
-    be executing at a time. Each launch is ordered behind both any previous
-    work in `stream` and any previous launches of `graphExec`. To execute a
-    graph concurrently, it must be instantiated multiple times into
-    multiple executable graphs.
+def make_cudaPos(size_t x, size_t y, size_t z):
+    """ Returns a :py:obj:`~.cudaPos` based on input parameters.
 
-    If any allocations created by `graphExec` remain unfreed (from a
-    previous launch) and `graphExec` was not instantiated with
-    :py:obj:`~.cudaGraphInstantiateFlagAutoFreeOnLaunch`, the launch will
-    fail with :py:obj:`~.cudaErrorInvalidValue`.
+    Returns a :py:obj:`~.cudaPos` based on the specified input parameters
+    `x`, `y`, and `z`.
 
     Parameters
     ----------
-    graphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        Executable graph to launch
-    stream : :py:obj:`~.CUstream` or :py:obj:`~.cudaStream_t`
-        Stream in which to launch the graph
+    x : size_t
+        X position
+    y : size_t
+        Y position
+    z : size_t
+        Z position
 
     Returns
     -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+    cudaError_t.cudaSuccess
+        cudaError_t.cudaSuccess
+    :py:obj:`~.cudaPos`
+        :py:obj:`~.cudaPos` specified by `x`, `y`, and `z`
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphExecDestroy`
+    make_cudaExtent, make_cudaPitchedPtr
     """
-    cdef ccudart.cudaStream_t cstream
-    if stream is None:
-        cstream = <ccudart.cudaStream_t><void_ptr>0
-    elif isinstance(stream, (cudaStream_t,cuda.CUstream)):
-        pstream = int(stream)
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
-    else:
-        pstream = int(cudaStream_t(stream))
-        cstream = <ccudart.cudaStream_t><void_ptr>pstream
+    err = cyruntime.make_cudaPos(x, y, z)
+    cdef cudaPos wrapper = cudaPos()
+    wrapper._ptr[0] = err
+    return wrapper
+{{endif}}
 
-    cdef ccudart.cudaGraphExec_t cgraphExec
-    if graphExec is None:
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(graphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        pgraphExec = int(graphExec)
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
-    else:
-        pgraphExec = int(cudaGraphExec_t(graphExec))
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
+{{if 'make_cudaExtent' in found_functions}}
 
-    err = ccudart.cudaGraphLaunch(cgraphExec, cstream)
-    return (cudaError_t(err),)
+@cython.embedsignature(True)
+def make_cudaExtent(size_t w, size_t h, size_t d):
+    """ Returns a :py:obj:`~.cudaExtent` based on input parameters.
+
+    Returns a :py:obj:`~.cudaExtent` based on the specified input
+    parameters `w`, `h`, and `d`.
+
+    Parameters
+    ----------
+    w : size_t
+        Width in elements when referring to array memory, in bytes when
+        referring to linear memory
+    h : size_t
+        Height in elements
+    d : size_t
+        Depth in elements
+
+    Returns
+    -------
+    cudaError_t.cudaSuccess
+        cudaError_t.cudaSuccess
+    :py:obj:`~.cudaExtent`
+        :py:obj:`~.cudaExtent` specified by `w`, `h`, and `d`
+
+    See Also
+    --------
+    make_cudaPitchedPtr, make_cudaPos
+    """
+    err = cyruntime.make_cudaExtent(w, h, d)
+    cdef cudaExtent wrapper = cudaExtent()
+    wrapper._ptr[0] = err
+    return wrapper
 {{endif}}
 
-{{if 'cudaGraphExecDestroy' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphExecDestroy(graphExec):
-    """ Destroys an executable graph.
+def cudaGraphicsEGLRegisterImage(image, unsigned int flags):
+    """ Registers an EGL image.
 
-    Destroys the executable graph specified by `graphExec`.
+    Registers the EGLImageKHR specified by `image` for access by CUDA. A
+    handle to the registered object is returned as `pCudaResource`.
+    Additional Mapping/Unmapping is not required for the registered
+    resource and :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be
+    directly called on the `pCudaResource`.
+
+    The application will be responsible for synchronizing access to shared
+    objects. The application must ensure that any pending operation which
+    access the objects have completed before passing control to CUDA. This
+    may be accomplished by issuing and waiting for glFinish command on all
+    GLcontexts (for OpenGL and likewise for other APIs). The application
+    will be also responsible for ensuring that any pending operation on the
+    registered CUDA resource has completed prior to executing subsequent
+    commands in other APIs accesing the same memory objects. This can be
+    accomplished by calling cuCtxSynchronize or cuEventSynchronize
+    (preferably).
+
+    The surface's intended usage is specified using `flags`, as follows:
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
+      how this resource will be used. It is therefore assumed that this
+      resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
+      will not write to this resource.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
+      CUDA will not read from this resource and will write over the entire
+      contents of the resource, so none of the data previously stored in
+      the resource will be preserved.
+
+    The EGLImageKHR is an object which can be used to create EGLImage
+    target resource. It is defined as a void pointer. typedef void*
+    EGLImageKHR
 
     Parameters
-    ----------
-    graphExec : :py:obj:`~.CUgraphExec` or :py:obj:`~.cudaGraphExec_t`
-        Executable graph to destroy
+    ----------
+    image : :py:obj:`~.EGLImageKHR`
+        An EGLImageKHR image which can be used to create target resource.
+    flags : unsigned int
+        Map flags
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+    pCudaResource : :py:obj:`~.cudaGraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cudaGraphInstantiate`, :py:obj:`~.cudaGraphUpload`, :py:obj:`~.cudaGraphLaunch`
+    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame`, :py:obj:`~.cuGraphicsEGLRegisterImage`
     """
-    cdef ccudart.cudaGraphExec_t cgraphExec
-    if graphExec is None:
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>0
-    elif isinstance(graphExec, (cudaGraphExec_t,cuda.CUgraphExec)):
-        pgraphExec = int(graphExec)
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
+    cdef cyruntime.EGLImageKHR cyimage
+    if image is None:
+        cyimage = <cyruntime.EGLImageKHR><void_ptr>0
+    elif isinstance(image, (EGLImageKHR,)):
+        pimage = int(image)
+        cyimage = <cyruntime.EGLImageKHR><void_ptr>pimage
     else:
-        pgraphExec = int(cudaGraphExec_t(graphExec))
-        cgraphExec = <ccudart.cudaGraphExec_t><void_ptr>pgraphExec
-
-    err = ccudart.cudaGraphExecDestroy(cgraphExec)
-    return (cudaError_t(err),)
+        pimage = int(EGLImageKHR(image))
+        cyimage = <cyruntime.EGLImageKHR><void_ptr>pimage
+    cdef cudaGraphicsResource_t pCudaResource = cudaGraphicsResource_t()
+    err = cyruntime.cudaGraphicsEGLRegisterImage(pCudaResource._ptr, cyimage, flags)
+    return (cudaError_t(err), pCudaResource)
 {{endif}}
 
-{{if 'cudaGraphDestroy' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphDestroy(graph):
-    """ Destroys a graph.
+def cudaEGLStreamConsumerConnect(eglStream):
+    """ Connect CUDA to EGLStream as a consumer.
 
-    Destroys the graph specified by `graph`, as well as all of its nodes.
+    Connect CUDA as a consumer to EGLStreamKHR specified by `eglStream`.
+
+    The EGLStreamKHR is an EGL object that transfers a sequence of image
+    frames from one API to another.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        Graph to destroy
+    eglStream : :py:obj:`~.EGLStreamKHR`
+        EGLStreamKHR handle
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Pointer to the returned connection handle
 
     See Also
     --------
-    :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerConnect`
     """
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.EGLStreamKHR cyeglStream
+    if eglStream is None:
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>0
+    elif isinstance(eglStream, (EGLStreamKHR,)):
+        peglStream = int(eglStream)
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    err = ccudart.cudaGraphDestroy(cgraph)
-    return (cudaError_t(err),)
+        peglStream = int(EGLStreamKHR(eglStream))
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
+    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
+    err = cyruntime.cudaEGLStreamConsumerConnect(<cyruntime.cudaEglStreamConnection*>conn._ptr, cyeglStream)
+    return (cudaError_t(err), conn)
 {{endif}}
 
-{{if 'cudaGraphDebugDotPrint' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphDebugDotPrint(graph, char* path, unsigned int flags):
-    """ Write a DOT file describing graph structure.
+def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags):
+    """ Connect CUDA to EGLStream as a consumer with given flags.
 
-    Using the provided `graph`, write to `path` a DOT formatted description
-    of the graph. By default this includes the graph topology, node types,
-    node id, kernel names and memcpy direction. `flags` can be specified to
-    write more detailed information about each node type such as parameter
-    values, kernel attributes, node and function handles.
+    Connect CUDA as a consumer to EGLStreamKHR specified by `stream` with
+    specified `flags` defined by :py:obj:`~.cudaEglResourceLocationFlags`.
+
+    The flags specify whether the consumer wants to access frames from
+    system memory or video memory. Default is
+    :py:obj:`~.cudaEglResourceLocationVidmem`.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph to create a DOT file from
-    path : bytes
-        The path to write the DOT file to
+    eglStream : :py:obj:`~.EGLStreamKHR`
+        EGLStreamKHR handle
     flags : unsigned int
-        Flags from cudaGraphDebugDotFlags for specifying which additional
-        node information to write
+        Flags denote intended location - system or video.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorOperatingSystem`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Pointer to the returned connection handle
+
+    See Also
+    --------
+    :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerConnectWithFlags`
     """
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.EGLStreamKHR cyeglStream
+    if eglStream is None:
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>0
+    elif isinstance(eglStream, (EGLStreamKHR,)):
+        peglStream = int(eglStream)
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    err = ccudart.cudaGraphDebugDotPrint(cgraph, path, flags)
-    return (cudaError_t(err),)
+        peglStream = int(EGLStreamKHR(eglStream))
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
+    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
+    err = cyruntime.cudaEGLStreamConsumerConnectWithFlags(<cyruntime.cudaEglStreamConnection*>conn._ptr, cyeglStream, flags)
+    return (cudaError_t(err), conn)
 {{endif}}
 
-{{if 'cudaUserObjectCreate' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaUserObjectCreate(ptr, destroy, unsigned int initialRefcount, unsigned int flags):
-    """ Create a user object.
-
-    Create a user object with the specified destructor callback and initial
-    reference count. The initial references are owned by the caller.
-
-    Destructor callbacks cannot make CUDA API calls and should avoid
-    blocking behavior, as they are executed by a shared internal thread.
-    Another thread may be signaled to perform such actions, if it does not
-    block forward progress of tasks scheduled through CUDA.
+def cudaEGLStreamConsumerDisconnect(conn):
+    """ Disconnect CUDA as a consumer to EGLStream .
 
-    See CUDA User Objects in the CUDA C++ Programming Guide for more
-    information on user objects.
+    Disconnect CUDA as a consumer to EGLStreamKHR.
 
     Parameters
     ----------
-    ptr : Any
-        The pointer to pass to the destroy function
-    destroy : :py:obj:`~.cudaHostFn_t`
-        Callback to free the user object when it is no longer in use
-    initialRefcount : unsigned int
-        The initial refcount to create the object with, typically 1. The
-        initial references are owned by the calling thread.
-    flags : unsigned int
-        Currently it is required to pass
-        :py:obj:`~.cudaUserObjectNoDestructorSync`, which is the only
-        defined flag. This indicates that the destroy callback cannot be
-        waited on by any CUDA API. Users requiring synchronization of the
-        callback should signal its completion manually.
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Conection to disconnect.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
-    object_out : :py:obj:`~.cudaUserObject_t`
-        Location to return the user object handle
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
 
     See Also
     --------
-    :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerDisconnect`
     """
-    cdef ccudart.cudaHostFn_t cdestroy
-    if destroy is None:
-        cdestroy = <ccudart.cudaHostFn_t><void_ptr>0
-    elif isinstance(destroy, (cudaHostFn_t)):
-        pdestroy = int(destroy)
-        cdestroy = <ccudart.cudaHostFn_t><void_ptr>pdestroy
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
     else:
-        pdestroy = int(cudaHostFn_t(destroy))
-        cdestroy = <ccudart.cudaHostFn_t><void_ptr>pdestroy
-
-    cdef cudaUserObject_t object_out = cudaUserObject_t()
-    cptr = utils.HelperInputVoidPtr(ptr)
-    cdef void* cptr_ptr = <void*><void_ptr>cptr.cptr
-    err = ccudart.cudaUserObjectCreate(<ccudart.cudaUserObject_t*>object_out._ptr, cptr_ptr, cdestroy, initialRefcount, flags)
-    return (cudaError_t(err), object_out)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    err = cyruntime.cudaEGLStreamConsumerDisconnect(cyconn)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaUserObjectRetain' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaUserObjectRetain(object, unsigned int count):
-    """ Retain a reference to a user object.
-
-    Retains new references to a user object. The new references are owned
-    by the caller.
+def cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int timeout):
+    """ Acquire an image frame from the EGLStream with CUDA as a consumer.
 
-    See CUDA User Objects in the CUDA C++ Programming Guide for more
-    information on user objects.
+    Acquire an image frame from EGLStreamKHR.
+    :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be called on
+    `pCudaResource` to get :py:obj:`~.cudaEglFrame`.
 
     Parameters
     ----------
-    object : :py:obj:`~.cudaUserObject_t`
-        The object to retain
-    count : unsigned int
-        The number of references to retain, typically 1. Must be nonzero
-        and not larger than INT_MAX.
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Connection on which to acquire
+    pCudaResource : :py:obj:`~.cudaGraphicsResource_t`
+        CUDA resource on which the EGLStream frame will be mapped for use.
+    pStream : :py:obj:`~.cudaStream_t`
+        CUDA stream for synchronization and any data migrations implied by
+        :py:obj:`~.cudaEglResourceLocationFlags`.
+    timeout : unsigned int
+        Desired timeout in usec.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorLaunchTimeout`
 
     See Also
     --------
-    :py:obj:`~.cudaUserObjectCreate`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`
     """
-    cdef ccudart.cudaUserObject_t cobject
-    if object is None:
-        cobject = <ccudart.cudaUserObject_t><void_ptr>0
-    elif isinstance(object, (cudaUserObject_t,cuda.CUuserObject)):
-        pobject = int(object)
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
+    cdef cyruntime.cudaStream_t *cypStream
+    if pStream is None:
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>NULL
+    elif isinstance(pStream, (cudaStream_t,driver.CUstream)):
+        ppStream = pStream.getPtr()
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>ppStream
+    elif isinstance(pStream, (int)):
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>pStream
     else:
-        pobject = int(cudaUserObject_t(object))
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
-
-    err = ccudart.cudaUserObjectRetain(cobject, count)
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, runtime.cudaStream_t'>, found " + str(type(pStream)))
+    cdef cyruntime.cudaGraphicsResource_t *cypCudaResource
+    if pCudaResource is None:
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t*><void_ptr>NULL
+    elif isinstance(pCudaResource, (cudaGraphicsResource_t,)):
+        ppCudaResource = pCudaResource.getPtr()
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t*><void_ptr>ppCudaResource
+    elif isinstance(pCudaResource, (int)):
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t*><void_ptr>pCudaResource
+    else:
+        raise TypeError("Argument 'pCudaResource' is not instance of type (expected <class 'int, runtime.cudaGraphicsResource_t'>, found " + str(type(pCudaResource)))
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
+    else:
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    err = cyruntime.cudaEGLStreamConsumerAcquireFrame(cyconn, cypCudaResource, cypStream, timeout)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaUserObjectRelease' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaUserObjectRelease(object, unsigned int count):
-    """ Release a reference to a user object.
-
-    Releases user object references owned by the caller. The object's
-    destructor is invoked if the reference count reaches zero.
-
-    It is undefined behavior to release references not owned by the caller,
-    or to use a user object handle after all references are released.
+def cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
+    """ Releases the last frame acquired from the EGLStream.
 
-    See CUDA User Objects in the CUDA C++ Programming Guide for more
-    information on user objects.
+    Release the acquired image frame specified by `pCudaResource` to
+    EGLStreamKHR.
 
     Parameters
     ----------
-    object : :py:obj:`~.cudaUserObject_t`
-        The object to release
-    count : unsigned int
-        The number of references to release, typically 1. Must be nonzero
-        and not larger than INT_MAX.
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Connection on which to release
+    pCudaResource : :py:obj:`~.cudaGraphicsResource_t`
+        CUDA resource whose corresponding frame is to be released
+    pStream : :py:obj:`~.cudaStream_t`
+        CUDA stream on which release will be done.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
 
     See Also
     --------
-    :py:obj:`~.cudaUserObjectCreate`, :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`
     """
-    cdef ccudart.cudaUserObject_t cobject
-    if object is None:
-        cobject = <ccudart.cudaUserObject_t><void_ptr>0
-    elif isinstance(object, (cudaUserObject_t,cuda.CUuserObject)):
-        pobject = int(object)
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
+    cdef cyruntime.cudaStream_t *cypStream
+    if pStream is None:
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>NULL
+    elif isinstance(pStream, (cudaStream_t,driver.CUstream)):
+        ppStream = pStream.getPtr()
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>ppStream
+    elif isinstance(pStream, (int)):
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>pStream
     else:
-        pobject = int(cudaUserObject_t(object))
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
-
-    err = ccudart.cudaUserObjectRelease(cobject, count)
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, runtime.cudaStream_t'>, found " + str(type(pStream)))
+    cdef cyruntime.cudaGraphicsResource_t cypCudaResource
+    if pCudaResource is None:
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(pCudaResource, (cudaGraphicsResource_t,)):
+        ppCudaResource = int(pCudaResource)
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t><void_ptr>ppCudaResource
+    else:
+        ppCudaResource = int(cudaGraphicsResource_t(pCudaResource))
+        cypCudaResource = <cyruntime.cudaGraphicsResource_t><void_ptr>ppCudaResource
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
+    else:
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    err = cyruntime.cudaEGLStreamConsumerReleaseFrame(cyconn, cypCudaResource, cypStream)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGraphRetainUserObject' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphRetainUserObject(graph, object, unsigned int count, unsigned int flags):
-    """ Retain a reference to a user object from a graph.
-
-    Creates or moves user object references that will be owned by a CUDA
-    graph.
+def cudaEGLStreamProducerConnect(eglStream, width, height):
+    """ Connect CUDA to EGLStream as a producer.
 
-    See CUDA User Objects in the CUDA C++ Programming Guide for more
-    information on user objects.
+    Connect CUDA as a producer to EGLStreamKHR specified by `stream`.
 
-    Parameters
-    ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph to associate the reference with
-    object : :py:obj:`~.cudaUserObject_t`
-        The user object to retain a reference for
-    count : unsigned int
-        The number of references to add to the graph, typically 1. Must be
-        nonzero and not larger than INT_MAX.
-    flags : unsigned int
-        The optional flag :py:obj:`~.cudaGraphUserObjectMove` transfers
-        references from the calling thread, rather than create new
-        references. Pass 0 to create new references.
+    The EGLStreamKHR is an EGL object that transfers a sequence of image
+    frames from one API to another.
+
+    Parameters
+    ----------
+    eglStream : :py:obj:`~.EGLStreamKHR`
+        EGLStreamKHR handle
+    width : :py:obj:`~.EGLint`
+        width of the image to be submitted to the stream
+    height : :py:obj:`~.EGLint`
+        height of the image to be submitted to the stream
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Pointer to the returned connection handle
 
     See Also
     --------
-    :py:obj:`~.cudaUserObjectCreate` :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphReleaseUserObject`, :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerConnect`
     """
-    cdef ccudart.cudaUserObject_t cobject
-    if object is None:
-        cobject = <ccudart.cudaUserObject_t><void_ptr>0
-    elif isinstance(object, (cudaUserObject_t,cuda.CUuserObject)):
-        pobject = int(object)
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
+    cdef cyruntime.EGLint cyheight
+    if height is None:
+        cyheight = <cyruntime.EGLint><void_ptr>0
+    elif isinstance(height, (EGLint,)):
+        pheight = int(height)
+        cyheight = <cyruntime.EGLint><void_ptr>pheight
     else:
-        pobject = int(cudaUserObject_t(object))
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+        pheight = int(EGLint(height))
+        cyheight = <cyruntime.EGLint><void_ptr>pheight
+    cdef cyruntime.EGLint cywidth
+    if width is None:
+        cywidth = <cyruntime.EGLint><void_ptr>0
+    elif isinstance(width, (EGLint,)):
+        pwidth = int(width)
+        cywidth = <cyruntime.EGLint><void_ptr>pwidth
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    err = ccudart.cudaGraphRetainUserObject(cgraph, cobject, count, flags)
-    return (cudaError_t(err),)
+        pwidth = int(EGLint(width))
+        cywidth = <cyruntime.EGLint><void_ptr>pwidth
+    cdef cyruntime.EGLStreamKHR cyeglStream
+    if eglStream is None:
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>0
+    elif isinstance(eglStream, (EGLStreamKHR,)):
+        peglStream = int(eglStream)
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
+    else:
+        peglStream = int(EGLStreamKHR(eglStream))
+        cyeglStream = <cyruntime.EGLStreamKHR><void_ptr>peglStream
+    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
+    err = cyruntime.cudaEGLStreamProducerConnect(<cyruntime.cudaEglStreamConnection*>conn._ptr, cyeglStream, cywidth, cyheight)
+    return (cudaError_t(err), conn)
 {{endif}}
 
-{{if 'cudaGraphReleaseUserObject' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphReleaseUserObject(graph, object, unsigned int count):
-    """ Release a user object reference from a graph.
-
-    Releases user object references owned by a graph.
+def cudaEGLStreamProducerDisconnect(conn):
+    """ Disconnect CUDA as a producer to EGLStream .
 
-    See CUDA User Objects in the CUDA C++ Programming Guide for more
-    information on user objects.
+    Disconnect CUDA as a producer to EGLStreamKHR.
 
     Parameters
     ----------
-    graph : :py:obj:`~.CUgraph` or :py:obj:`~.cudaGraph_t`
-        The graph that will release the reference
-    object : :py:obj:`~.cudaUserObject_t`
-        The user object to release a reference for
-    count : unsigned int
-        The number of references to release, typically 1. Must be nonzero
-        and not larger than INT_MAX.
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Conection to disconnect.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
 
     See Also
     --------
-    :py:obj:`~.cudaUserObjectCreate` :py:obj:`~.cudaUserObjectRetain`, :py:obj:`~.cudaUserObjectRelease`, :py:obj:`~.cudaGraphRetainUserObject`, :py:obj:`~.cudaGraphCreate`
+    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerDisconnect`
     """
-    cdef ccudart.cudaUserObject_t cobject
-    if object is None:
-        cobject = <ccudart.cudaUserObject_t><void_ptr>0
-    elif isinstance(object, (cudaUserObject_t,cuda.CUuserObject)):
-        pobject = int(object)
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
-    else:
-        pobject = int(cudaUserObject_t(object))
-        cobject = <ccudart.cudaUserObject_t><void_ptr>pobject
-
-    cdef ccudart.cudaGraph_t cgraph
-    if graph is None:
-        cgraph = <ccudart.cudaGraph_t><void_ptr>0
-    elif isinstance(graph, (cudaGraph_t,cuda.CUgraph)):
-        pgraph = int(graph)
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
     else:
-        pgraph = int(cudaGraph_t(graph))
-        cgraph = <ccudart.cudaGraph_t><void_ptr>pgraph
-
-    err = ccudart.cudaGraphReleaseUserObject(cgraph, cobject, count)
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    err = cyruntime.cudaEGLStreamProducerDisconnect(cyconn)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if 'cudaGetDriverEntryPoint' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGetDriverEntryPoint(char* symbol, unsigned long long flags):
-    """ Returns the requested driver API function pointer.
-
-    Returns in `**funcPtr` the address of the CUDA driver function for the
-    requested flags.
-
-    For a requested driver symbol, if the CUDA version in which the driver
-    symbol was introduced is less than or equal to the CUDA runtime
-    version, the API will return the function pointer to the corresponding
-    versioned driver function.
-
-    The pointer returned by the API should be cast to a function pointer
-    matching the requested driver function's definition in the API header
-    file. The function pointer typedef can be picked up from the
-    corresponding typedefs header file. For example, cudaTypedefs.h
-    consists of function pointer typedefs for driver APIs defined in
-    cuda.h.
-
-    The API will return :py:obj:`~.cudaErrorSymbolNotFound` if the
-    requested driver function is not supported on the platform, no ABI
-    compatible driver function exists for the CUDA runtime version or if
-    the driver symbol is invalid.
-
-    The requested flags can be:
+def cudaEGLStreamProducerPresentFrame(conn, eglframe not None : cudaEglFrame, pStream):
+    """ Present a CUDA eglFrame to the EGLStream with CUDA as a producer.
 
-    - :py:obj:`~.cudaEnableDefault`: This is the default mode. This is
-      equivalent to :py:obj:`~.cudaEnablePerThreadDefaultStream` if the
-      code is compiled with --default-stream per-thread compilation flag or
-      the macro CUDA_API_PER_THREAD_DEFAULT_STREAM is defined;
-      :py:obj:`~.cudaEnableLegacyStream` otherwise.
+    The :py:obj:`~.cudaEglFrame` is defined as:
 
-    - :py:obj:`~.cudaEnableLegacyStream`: This will enable the search for
-      all driver symbols that match the requested driver symbol name except
-      the corresponding per-thread versions.
+    **View CUDA Toolkit Documentation for a C++ code example**
 
-    - :py:obj:`~.cudaEnablePerThreadDefaultStream`: This will enable the
-      search for all driver symbols that match the requested driver symbol
-      name including the per-thread versions. If a per-thread version is
-      not found, the API will return the legacy version of the driver
-      function.
+    For :py:obj:`~.cudaEglFrame` of type :py:obj:`~.cudaEglFrameTypePitch`,
+    the application may present sub-region of a memory allocation. In that
+    case, :py:obj:`~.cudaPitchedPtr.ptr` will specify the start address of
+    the sub-region in the allocation and :py:obj:`~.cudaEglPlaneDesc` will
+    specify the dimensions of the sub-region.
 
     Parameters
     ----------
-    symbol : bytes
-        The base name of the driver API function to look for. As an
-        example, for the driver API :py:obj:`~.cuMemAlloc_v2`, `symbol`
-        would be cuMemAlloc. Note that the API will use the CUDA runtime
-        version to return the address to the most recent ABI compatible
-        driver symbol, :py:obj:`~.cuMemAlloc` or :py:obj:`~.cuMemAlloc_v2`.
-    flags : unsigned long long
-        Flags to specify search options.
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Connection on which to present the CUDA array
+    eglframe : :py:obj:`~.cudaEglFrame`
+        CUDA Eglstream Proucer Frame handle to be sent to the consumer over
+        EglStream.
+    pStream : :py:obj:`~.cudaStream_t`
+        CUDA stream on which to present the frame.
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorNotSupported`, :py:obj:`~.cudaErrorSymbolNotFound`
-    funcPtr : Any
-        Location to return the function pointer to the requested driver
-        function
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
 
     See Also
     --------
-    :py:obj:`~.cuGetProcAddress`
+    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerPresentFrame`
     """
-    cdef void_ptr funcPtr = 0
-    err = ccudart.cudaGetDriverEntryPoint(symbol, <void**>&funcPtr, flags)
-    return (cudaError_t(err), funcPtr)
-{{endif}}
-
-{{if 'cudaGetExportTable' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaGetExportTable(pExportTableId : Optional[cudaUUID_t]):
-    """"""
-    cdef void_ptr ppExportTable = 0
-    cdef ccudart.cudaUUID_t* cpExportTableId_ptr = pExportTableId._ptr if pExportTableId != None else NULL
-    err = ccudart.cudaGetExportTable(<const void**>&ppExportTable, cpExportTableId_ptr)
-    return (cudaError_t(err), ppExportTable)
+    cdef cyruntime.cudaStream_t *cypStream
+    if pStream is None:
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>NULL
+    elif isinstance(pStream, (cudaStream_t,driver.CUstream)):
+        ppStream = pStream.getPtr()
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>ppStream
+    elif isinstance(pStream, (int)):
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>pStream
+    else:
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, runtime.cudaStream_t'>, found " + str(type(pStream)))
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
+    else:
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    err = cyruntime.cudaEGLStreamProducerPresentFrame(cyconn, eglframe._ptr[0], cypStream)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'make_cudaPitchedPtr' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def make_cudaPitchedPtr(d, size_t p, size_t xsz, size_t ysz):
-    """ Returns a :py:obj:`~.cudaPitchedPtr` based on input parameters.
+def cudaEGLStreamProducerReturnFrame(conn, eglframe : Optional[cudaEglFrame], pStream):
+    """ Return the CUDA eglFrame to the EGLStream last released by the consumer.
 
-    Returns a :py:obj:`~.cudaPitchedPtr` based on the specified input
-    parameters `d`, `p`, `xsz`, and `ysz`.
+    This API can potentially return cudaErrorLaunchTimeout if the consumer
+    has not returned a frame to EGL stream. If timeout is returned the
+    application can retry.
 
     Parameters
     ----------
-    d : Any
-        Pointer to allocated memory
-    p : size_t
-        Pitch of allocated memory in bytes
-    xsz : size_t
-        Logical width of allocation in elements
-    ysz : size_t
-        Logical height of allocation in elements
+    conn : :py:obj:`~.cudaEglStreamConnection`
+        Connection on which to present the CUDA array
+    eglframe : :py:obj:`~.cudaEglFrame`
+        CUDA Eglstream Proucer Frame handle returned from the consumer over
+        EglStream.
+    pStream : :py:obj:`~.cudaStream_t`
+        CUDA stream on which to return the frame.
 
     Returns
     -------
-    cudaError_t.cudaSuccess
-        cudaError_t.cudaSuccess
-    :py:obj:`~.cudaPitchedPtr`
-        :py:obj:`~.cudaPitchedPtr` specified by `d`, `p`, `xsz`, and `ysz`
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
 
     See Also
     --------
-    make_cudaExtent, make_cudaPos
+    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cuEGLStreamProducerReturnFrame`
     """
-    cd = utils.HelperInputVoidPtr(d)
-    cdef void* cd_ptr = <void*><void_ptr>cd.cptr
-    cdef ccudart.cudaPitchedPtr err
-    err = ccudart.make_cudaPitchedPtr(cd_ptr, p, xsz, ysz)
-    cdef cudaPitchedPtr wrapper = cudaPitchedPtr()
-    wrapper._ptr[0] = err
-    return wrapper
+    cdef cyruntime.cudaStream_t *cypStream
+    if pStream is None:
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>NULL
+    elif isinstance(pStream, (cudaStream_t,driver.CUstream)):
+        ppStream = pStream.getPtr()
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>ppStream
+    elif isinstance(pStream, (int)):
+        cypStream = <cyruntime.cudaStream_t*><void_ptr>pStream
+    else:
+        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, runtime.cudaStream_t'>, found " + str(type(pStream)))
+    cdef cyruntime.cudaEglStreamConnection *cyconn
+    if conn is None:
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>NULL
+    elif isinstance(conn, (cudaEglStreamConnection,driver.CUeglStreamConnection)):
+        pconn = conn.getPtr()
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>pconn
+    elif isinstance(conn, (int)):
+        cyconn = <cyruntime.cudaEglStreamConnection*><void_ptr>conn
+    else:
+        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, runtime.cudaEglStreamConnection'>, found " + str(type(conn)))
+    cdef cyruntime.cudaEglFrame* cyeglframe_ptr = eglframe._ptr if eglframe != None else NULL
+    err = cyruntime.cudaEGLStreamProducerReturnFrame(cyconn, cyeglframe_ptr, cypStream)
+    return (cudaError_t(err),)
 {{endif}}
 
-{{if 'make_cudaPos' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def make_cudaPos(size_t x, size_t y, size_t z):
-    """ Returns a :py:obj:`~.cudaPos` based on input parameters.
+def cudaGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned int mipLevel):
+    """ Get an eglFrame through which to access a registered EGL graphics resource.
 
-    Returns a :py:obj:`~.cudaPos` based on the specified input parameters
-    `x`, `y`, and `z`.
+    Returns in `*eglFrame` an eglFrame pointer through which the registered
+    graphics resource `resource` may be accessed. This API can only be
+    called for EGL graphics resources.
+
+    The :py:obj:`~.cudaEglFrame` is defined as
+
+    **View CUDA Toolkit Documentation for a C++ code example**
 
     Parameters
     ----------
-    x : size_t
-        X position
-    y : size_t
-        Y position
-    z : size_t
-        Z position
+    resource : :py:obj:`~.cudaGraphicsResource_t`
+        Registered resource to access.
+    index : unsigned int
+        Index for cubemap surfaces.
+    mipLevel : unsigned int
+        Mipmap level for the subresource to access.
 
     Returns
     -------
-    cudaError_t.cudaSuccess
-        cudaError_t.cudaSuccess
-    :py:obj:`~.cudaPos`
-        :py:obj:`~.cudaPos` specified by `x`, `y`, and `z`
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+    eglFrame : :py:obj:`~.cudaEglFrame`
+        Returned eglFrame.
 
     See Also
     --------
-    make_cudaExtent, make_cudaPitchedPtr
+    :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsResourceGetMappedEglFrame`
+
+    Notes
+    -----
+    Note that in case of multiplanar `*eglFrame`, pitch of only first plane (unsigned int :py:obj:`~.cudaEglPlaneDesc.pitch`) is to be considered by the application.
     """
-    cdef ccudart.cudaPos err
-    err = ccudart.make_cudaPos(x, y, z)
-    cdef cudaPos wrapper = cudaPos()
-    wrapper._ptr[0] = err
-    return wrapper
+    cdef cyruntime.cudaGraphicsResource_t cyresource
+    if resource is None:
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>0
+    elif isinstance(resource, (cudaGraphicsResource_t,)):
+        presource = int(resource)
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
+    else:
+        presource = int(cudaGraphicsResource_t(resource))
+        cyresource = <cyruntime.cudaGraphicsResource_t><void_ptr>presource
+    cdef cudaEglFrame eglFrame = cudaEglFrame()
+    err = cyruntime.cudaGraphicsResourceGetMappedEglFrame(<cyruntime.cudaEglFrame*>eglFrame._ptr, cyresource, index, mipLevel)
+    return (cudaError_t(err), eglFrame)
 {{endif}}
 
-{{if 'make_cudaExtent' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def make_cudaExtent(size_t w, size_t h, size_t d):
-    """ Returns a :py:obj:`~.cudaExtent` based on input parameters.
+def cudaEventCreateFromEGLSync(eglSync, unsigned int flags):
+    """ Creates an event from EGLSync object.
 
-    Returns a :py:obj:`~.cudaExtent` based on the specified input
-    parameters `w`, `h`, and `d`.
+    Creates an event *phEvent from an EGLSyncKHR eglSync with the flages
+    specified via `flags`. Valid flags include:
+
+    - :py:obj:`~.cudaEventDefault`: Default event creation flag.
+
+    - :py:obj:`~.cudaEventBlockingSync`: Specifies that the created event
+      should use blocking synchronization. A CPU thread that uses
+      :py:obj:`~.cudaEventSynchronize()` to wait on an event created with
+      this flag will block until the event has actually been completed.
+
+    :py:obj:`~.cudaEventRecord` and TimingData are not supported for events
+    created from EGLSync.
+
+    The EGLSyncKHR is an opaque handle to an EGL sync object. typedef void*
+    EGLSyncKHR
 
     Parameters
     ----------
-    w : size_t
-        Width in elements when referring to array memory, in bytes when
-        referring to linear memory
-    h : size_t
-        Height in elements
-    d : size_t
-        Depth in elements
+    eglSync : :py:obj:`~.EGLSyncKHR`
+        Opaque handle to EGLSync object
+    flags : unsigned int
+        Event creation flags
 
     Returns
     -------
-    cudaError_t.cudaSuccess
-        cudaError_t.cudaSuccess
-    :py:obj:`~.cudaExtent`
-        :py:obj:`~.cudaExtent` specified by `w`, `h`, and `d`
+    cudaError_t
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorMemoryAllocation`
+    phEvent : :py:obj:`~.cudaEvent_t`
+        Returns newly created event
 
     See Also
     --------
-    make_cudaPitchedPtr, make_cudaPos
+    :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`
     """
-    cdef ccudart.cudaExtent err
-    err = ccudart.make_cudaExtent(w, h, d)
-    cdef cudaExtent wrapper = cudaExtent()
-    wrapper._ptr[0] = err
-    return wrapper
+    cdef cyruntime.EGLSyncKHR cyeglSync
+    if eglSync is None:
+        cyeglSync = <cyruntime.EGLSyncKHR><void_ptr>0
+    elif isinstance(eglSync, (EGLSyncKHR,)):
+        peglSync = int(eglSync)
+        cyeglSync = <cyruntime.EGLSyncKHR><void_ptr>peglSync
+    else:
+        peglSync = int(EGLSyncKHR(eglSync))
+        cyeglSync = <cyruntime.EGLSyncKHR><void_ptr>peglSync
+    cdef cudaEvent_t phEvent = cudaEvent_t()
+    err = cyruntime.cudaEventCreateFromEGLSync(<cyruntime.cudaEvent_t*>phEvent._ptr, cyeglSync, flags)
+    return (cudaError_t(err), phEvent)
 {{endif}}
 
-{{if True or 'cudaProfilerInitialize' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cudaProfilerInitialize(char* configFile, char* outputFile, outputMode not None : cudaOutputMode_t):
@@ -26086,12 +26421,12 @@ def cudaProfilerInitialize(char* configFile, char* outputFile, outputMode not No
     --------
     :py:obj:`~.cudaProfilerStart`, :py:obj:`~.cudaProfilerStop`, :py:obj:`~.cuProfilerInitialize`
     """
-    cdef ccudart.cudaOutputMode_t coutputMode = outputMode.value
-    err = ccudart.cudaProfilerInitialize(configFile, outputFile, coutputMode)
+    cdef cyruntime.cudaOutputMode_t cyoutputMode = outputMode.value
+    err = cyruntime.cudaProfilerInitialize(configFile, outputFile, cyoutputMode)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaProfilerStart' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cudaProfilerStart():
@@ -26114,11 +26449,11 @@ def cudaProfilerStart():
     --------
     :py:obj:`~.cudaProfilerInitialize`, :py:obj:`~.cudaProfilerStop`, :py:obj:`~.cuProfilerStart`
     """
-    err = ccudart.cudaProfilerStart()
+    err = cyruntime.cudaProfilerStart()
     return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaProfilerStop' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
 def cudaProfilerStop():
@@ -26135,673 +26470,450 @@ def cudaProfilerStop():
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`
-
-    See Also
-    --------
-    :py:obj:`~.cudaProfilerInitialize`, :py:obj:`~.cudaProfilerStart`, :py:obj:`~.cuProfilerStop`
-    """
-    err = ccudart.cudaProfilerStop()
-    return (cudaError_t(err),)
-{{endif}}
-
-{{if True or 'cudaGraphicsEGLRegisterImage' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaGraphicsEGLRegisterImage(image, unsigned int flags):
-    """ Registers an EGL image.
-
-    Registers the EGLImageKHR specified by `image` for access by CUDA. A
-    handle to the registered object is returned as `pCudaResource`.
-    Additional Mapping/Unmapping is not required for the registered
-    resource and :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be
-    directly called on the `pCudaResource`.
-
-    The application will be responsible for synchronizing access to shared
-    objects. The application must ensure that any pending operation which
-    access the objects have completed before passing control to CUDA. This
-    may be accomplished by issuing and waiting for glFinish command on all
-    GLcontexts (for OpenGL and likewise for other APIs). The application
-    will be also responsible for ensuring that any pending operation on the
-    registered CUDA resource has completed prior to executing subsequent
-    commands in other APIs accesing the same memory objects. This can be
-    accomplished by calling cuCtxSynchronize or cuEventSynchronize
-    (preferably).
-
-    The surface's intended usage is specified using `flags`, as follows:
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
-      how this resource will be used. It is therefore assumed that this
-      resource will be read from and written to by CUDA. This is the
-      default value.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
-      will not write to this resource.
-
-    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
-      CUDA will not read from this resource and will write over the entire
-      contents of the resource, so none of the data previously stored in
-      the resource will be preserved.
-
-    The EGLImageKHR is an object which can be used to create EGLImage
-    target resource. It is defined as a void pointer. typedef void*
-    EGLImageKHR
-
-    Parameters
-    ----------
-    image : :py:obj:`~.EGLImageKHR`
-        An EGLImageKHR image which can be used to create target resource.
-    flags : unsigned int
-        Map flags
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-    pCudaResource : :py:obj:`~.cudaGraphicsResource_t`
-        Pointer to the returned object handle
-
-    See Also
-    --------
-    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame`, :py:obj:`~.cuGraphicsEGLRegisterImage`
-    """
-    cdef ccudart.EGLImageKHR cimage
-    if image is None:
-        cimage = <ccudart.EGLImageKHR><void_ptr>0
-    elif isinstance(image, (EGLImageKHR)):
-        pimage = int(image)
-        cimage = <ccudart.EGLImageKHR><void_ptr>pimage
-    else:
-        pimage = int(EGLImageKHR(image))
-        cimage = <ccudart.EGLImageKHR><void_ptr>pimage
-
-    cdef cudaGraphicsResource_t pCudaResource = cudaGraphicsResource_t()
-    err = ccudart.cudaGraphicsEGLRegisterImage(pCudaResource._ptr, cimage, flags)
-    return (cudaError_t(err), pCudaResource)
-{{endif}}
-
-{{if True or 'cudaEGLStreamConsumerConnect' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaEGLStreamConsumerConnect(eglStream):
-    """ Connect CUDA to EGLStream as a consumer.
-
-    Connect CUDA as a consumer to EGLStreamKHR specified by `eglStream`.
-
-    The EGLStreamKHR is an EGL object that transfers a sequence of image
-    frames from one API to another.
-
-    Parameters
-    ----------
-    eglStream : :py:obj:`~.EGLStreamKHR`
-        EGLStreamKHR handle
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Pointer to the returned connection handle
-
-    See Also
-    --------
-    :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerConnect`
-    """
-    cdef ccudart.EGLStreamKHR ceglStream
-    if eglStream is None:
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>0
-    elif isinstance(eglStream, (EGLStreamKHR)):
-        peglStream = int(eglStream)
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
-    else:
-        peglStream = int(EGLStreamKHR(eglStream))
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
-
-    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
-    err = ccudart.cudaEGLStreamConsumerConnect(<ccudart.cudaEglStreamConnection*>conn._ptr, ceglStream)
-    return (cudaError_t(err), conn)
-{{endif}}
-
-{{if True or 'cudaEGLStreamConsumerConnectWithFlags' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaEGLStreamConsumerConnectWithFlags(eglStream, unsigned int flags):
-    """ Connect CUDA to EGLStream as a consumer with given flags.
-
-    Connect CUDA as a consumer to EGLStreamKHR specified by `stream` with
-    specified `flags` defined by :py:obj:`~.cudaEglResourceLocationFlags`.
-
-    The flags specify whether the consumer wants to access frames from
-    system memory or video memory. Default is
-    :py:obj:`~.cudaEglResourceLocationVidmem`.
-
-    Parameters
-    ----------
-    eglStream : :py:obj:`~.EGLStreamKHR`
-        EGLStreamKHR handle
-    flags : unsigned int
-        Flags denote intended location - system or video.
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Pointer to the returned connection handle
-
-    See Also
-    --------
-    :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerConnectWithFlags`
-    """
-    cdef ccudart.EGLStreamKHR ceglStream
-    if eglStream is None:
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>0
-    elif isinstance(eglStream, (EGLStreamKHR)):
-        peglStream = int(eglStream)
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
-    else:
-        peglStream = int(EGLStreamKHR(eglStream))
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
-
-    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
-    err = ccudart.cudaEGLStreamConsumerConnectWithFlags(<ccudart.cudaEglStreamConnection*>conn._ptr, ceglStream, flags)
-    return (cudaError_t(err), conn)
-{{endif}}
-
-{{if True or 'cudaEGLStreamConsumerDisconnect' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaEGLStreamConsumerDisconnect(conn):
-    """ Disconnect CUDA as a consumer to EGLStream .
-
-    Disconnect CUDA as a consumer to EGLStreamKHR.
-
-    Parameters
-    ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Conection to disconnect.
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-
-    See Also
-    --------
-    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerDisconnect`
-    """
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
-    else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccudart.cudaEGLStreamConsumerDisconnect(cconn)
-    return (cudaError_t(err),)
-{{endif}}
-
-{{if True or 'cudaEGLStreamConsumerAcquireFrame' in found_functions}}
-
-@cython.embedsignature(True)
-def cudaEGLStreamConsumerAcquireFrame(conn, pCudaResource, pStream, unsigned int timeout):
-    """ Acquire an image frame from the EGLStream with CUDA as a consumer.
-
-    Acquire an image frame from EGLStreamKHR.
-    :py:obj:`~.cudaGraphicsResourceGetMappedEglFrame` can be called on
-    `pCudaResource` to get :py:obj:`~.cudaEglFrame`.
-
-    Parameters
-    ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Connection on which to acquire
-    pCudaResource : :py:obj:`~.cudaGraphicsResource_t`
-        CUDA resource on which the EGLStream frame will be mapped for use.
-    pStream : :py:obj:`~.cudaStream_t`
-        CUDA stream for synchronization and any data migrations implied by
-        :py:obj:`~.cudaEglResourceLocationFlags`.
-    timeout : unsigned int
-        Desired timeout in usec.
-
-    Returns
-    -------
-    cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`, :py:obj:`~.cudaErrorLaunchTimeout`
+        :py:obj:`~.cudaSuccess`
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerReleaseFrame`, :py:obj:`~.cuEGLStreamConsumerAcquireFrame`
+    :py:obj:`~.cudaProfilerInitialize`, :py:obj:`~.cudaProfilerStart`, :py:obj:`~.cuProfilerStop`
     """
-    cdef ccudart.cudaStream_t *cpStream
-    if pStream is None:
-        cpStream = <ccudart.cudaStream_t*><void_ptr>NULL
-    elif isinstance(pStream, (cudaStream_t,cuda.CUstream)):
-        ppStream = pStream.getPtr()
-        cpStream = <ccudart.cudaStream_t*><void_ptr>ppStream
-    elif isinstance(pStream, (int)):
-        cpStream = <ccudart.cudaStream_t*><void_ptr>pStream
-    else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cudart.cudaStream_t,cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccudart.cudaGraphicsResource_t *cpCudaResource
-    if pCudaResource is None:
-        cpCudaResource = <ccudart.cudaGraphicsResource_t*><void_ptr>NULL
-    elif isinstance(pCudaResource, (cudaGraphicsResource_t)):
-        ppCudaResource = pCudaResource.getPtr()
-        cpCudaResource = <ccudart.cudaGraphicsResource_t*><void_ptr>ppCudaResource
-    elif isinstance(pCudaResource, (int)):
-        cpCudaResource = <ccudart.cudaGraphicsResource_t*><void_ptr>pCudaResource
-    else:
-        raise TypeError("Argument 'pCudaResource' is not instance of type (expected <class 'int, cudart.cudaGraphicsResource_t'>, found " + str(type(pCudaResource)))
-
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
-    else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccudart.cudaEGLStreamConsumerAcquireFrame(cconn, cpCudaResource, cpStream, timeout)
+    err = cyruntime.cudaProfilerStop()
     return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaEGLStreamConsumerReleaseFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEGLStreamConsumerReleaseFrame(conn, pCudaResource, pStream):
-    """ Releases the last frame acquired from the EGLStream.
+def cudaGLGetDevices(unsigned int cudaDeviceCount, deviceList not None : cudaGLDeviceList):
+    """ Gets the CUDA devices associated with the current OpenGL context.
 
-    Release the acquired image frame specified by `pCudaResource` to
-    EGLStreamKHR.
+    Returns in `*pCudaDeviceCount` the number of CUDA-compatible devices
+    corresponding to the current OpenGL context. Also returns in
+    `*pCudaDevices` at most `cudaDeviceCount` of the CUDA-compatible
+    devices corresponding to the current OpenGL context. If any of the GPUs
+    being used by the current OpenGL context are not CUDA capable then the
+    call will return cudaErrorNoDevice.
 
     Parameters
     ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Connection on which to release
-    pCudaResource : :py:obj:`~.cudaGraphicsResource_t`
-        CUDA resource whose corresponding frame is to be released
-    pStream : :py:obj:`~.cudaStream_t`
-        CUDA stream on which release will be done.
+    cudaDeviceCount : unsigned int
+        The size of the output device array `pCudaDevices`
+    deviceList : cudaGLDeviceList
+        The set of devices to return. This set may be cudaGLDeviceListAll
+        for all devices, cudaGLDeviceListCurrentFrame for the devices used
+        to render the current frame (in SLI), or cudaGLDeviceListNextFrame
+        for the devices used to render the next frame (in SLI).
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+        cudaSuccess
+        cudaErrorNoDevice
+        cudaErrorInvalidGraphicsContext
+        cudaErrorUnknown
+    pCudaDeviceCount : unsigned int
+        Returned number of CUDA devices corresponding to the current OpenGL
+        context
+    pCudaDevices : List[int]
+        Returned CUDA devices corresponding to the current OpenGL context
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamConsumerConnect`, :py:obj:`~.cudaEGLStreamConsumerDisconnect`, :py:obj:`~.cudaEGLStreamConsumerAcquireFrame`, :py:obj:`~.cuEGLStreamConsumerReleaseFrame`
-    """
-    cdef ccudart.cudaStream_t *cpStream
-    if pStream is None:
-        cpStream = <ccudart.cudaStream_t*><void_ptr>NULL
-    elif isinstance(pStream, (cudaStream_t,cuda.CUstream)):
-        ppStream = pStream.getPtr()
-        cpStream = <ccudart.cudaStream_t*><void_ptr>ppStream
-    elif isinstance(pStream, (int)):
-        cpStream = <ccudart.cudaStream_t*><void_ptr>pStream
-    else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cudart.cudaStream_t,cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccudart.cudaGraphicsResource_t cpCudaResource
-    if pCudaResource is None:
-        cpCudaResource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(pCudaResource, (cudaGraphicsResource_t)):
-        ppCudaResource = int(pCudaResource)
-        cpCudaResource = <ccudart.cudaGraphicsResource_t><void_ptr>ppCudaResource
-    else:
-        ppCudaResource = int(cudaGraphicsResource_t(pCudaResource))
-        cpCudaResource = <ccudart.cudaGraphicsResource_t><void_ptr>ppCudaResource
+    ~.cudaGraphicsUnregisterResource
+    ~.cudaGraphicsMapResources
+    ~.cudaGraphicsSubResourceGetMappedArray
+    ~.cudaGraphicsResourceGetMappedPointer
+    ~.cuGLGetDevices
 
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
-    else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
+    Notes
+    -----
+    This function is not supported on Mac OS X.
 
-    err = ccudart.cudaEGLStreamConsumerReleaseFrame(cconn, cpCudaResource, cpStream)
-    return (cudaError_t(err),)
+    """
+    cdef unsigned int pCudaDeviceCount = 0
+    cdef int* cypCudaDevices = NULL
+    pypCudaDevices = []
+    if cudaDeviceCount != 0:
+        cypCudaDevices = <int*>calloc(cudaDeviceCount, sizeof(int))
+        if cypCudaDevices is NULL:
+            raise MemoryError('Failed to allocate length x size memory: ' + str(cudaDeviceCount) + 'x' + str(sizeof(int)))
+    cdef cyruntime.cudaGLDeviceList cydeviceList = deviceList.value
+    err = cyruntime.cudaGLGetDevices(&pCudaDeviceCount, cypCudaDevices, cudaDeviceCount, cydeviceList)
+    if cudaError_t(err) == cudaError_t(0):
+        pypCudaDevices = [<void_ptr>cypCudaDevices[idx] for idx in range(cudaDeviceCount)]
+    if cypCudaDevices is not NULL:
+        free(cypCudaDevices)
+    return (cudaError_t(err), pCudaDeviceCount, pypCudaDevices)
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerConnect' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEGLStreamProducerConnect(eglStream, width, height):
-    """ Connect CUDA to EGLStream as a producer.
+def cudaGraphicsGLRegisterImage(image, target, unsigned int flags):
+    """ Register an OpenGL texture or renderbuffer object.
 
-    Connect CUDA as a producer to EGLStreamKHR specified by `stream`.
+    Registers the texture or renderbuffer object specified by `image` for
+    access by CUDA. A handle to the registered object is returned as
+    `resource`.
 
-    The EGLStreamKHR is an EGL object that transfers a sequence of image
-    frames from one API to another.
+    `target` must match the type of the object, and must be one of
+    :py:obj:`~.GL_TEXTURE_2D`, :py:obj:`~.GL_TEXTURE_RECTANGLE`,
+    :py:obj:`~.GL_TEXTURE_CUBE_MAP`, :py:obj:`~.GL_TEXTURE_3D`,
+    :py:obj:`~.GL_TEXTURE_2D_ARRAY`, or :py:obj:`~.GL_RENDERBUFFER`.
+
+    The register flags `flags` specify the intended usage, as follows:
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
+      how this resource will be used. It is therefore assumed that this
+      resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
+      will not write to this resource.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
+      CUDA will not read from this resource and will write over the entire
+      contents of the resource, so none of the data previously stored in
+      the resource will be preserved.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsSurfaceLoadStore`: Specifies that
+      CUDA will bind this resource to a surface reference.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsTextureGather`: Specifies that
+      CUDA will perform texture gather operations on this resource.
+
+    The following image formats are supported. For brevity's sake, the list
+    is abbreviated. For ex., {GL_R, GL_RG} X {8, 16} would expand to the
+    following 4 formats {GL_R8, GL_R16, GL_RG8, GL_RG16} :
+
+    - GL_RED, GL_RG, GL_RGBA, GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA,
+      GL_INTENSITY
+
+    - {GL_R, GL_RG, GL_RGBA} X {8, 16, 16F, 32F, 8UI, 16UI, 32UI, 8I, 16I,
+      32I}
+
+    - {GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY} X {8, 16,
+      16F_ARB, 32F_ARB, 8UI_EXT, 16UI_EXT, 32UI_EXT, 8I_EXT, 16I_EXT,
+      32I_EXT}
+
+    The following image classes are currently disallowed:
+
+    - Textures with borders
+
+    - Multisampled renderbuffers
 
     Parameters
     ----------
-    eglStream : :py:obj:`~.EGLStreamKHR`
-        EGLStreamKHR handle
-    width : :py:obj:`~.EGLint`
-        width of the image to be submitted to the stream
-    height : :py:obj:`~.EGLint`
-        height of the image to be submitted to the stream
+    image : :py:obj:`~.GLuint`
+        name of texture or renderbuffer object to be registered
+    target : :py:obj:`~.GLenum`
+        Identifies the type of object specified by `image`
+    flags : unsigned int
+        Register flags
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Pointer to the returned connection handle
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
+    resource : :py:obj:`~.cudaGraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerConnect`
+    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsGLRegisterImage`
     """
-    cdef ccudart.EGLint cheight
-    if height is None:
-        cheight = <ccudart.EGLint><void_ptr>0
-    elif isinstance(height, (EGLint)):
-        pheight = int(height)
-        cheight = <ccudart.EGLint><void_ptr>pheight
-    else:
-        pheight = int(EGLint(height))
-        cheight = <ccudart.EGLint><void_ptr>pheight
-
-    cdef ccudart.EGLint cwidth
-    if width is None:
-        cwidth = <ccudart.EGLint><void_ptr>0
-    elif isinstance(width, (EGLint)):
-        pwidth = int(width)
-        cwidth = <ccudart.EGLint><void_ptr>pwidth
+    cdef cyruntime.GLenum cytarget
+    if target is None:
+        cytarget = <cyruntime.GLenum><void_ptr>0
+    elif isinstance(target, (GLenum,)):
+        ptarget = int(target)
+        cytarget = <cyruntime.GLenum><void_ptr>ptarget
     else:
-        pwidth = int(EGLint(width))
-        cwidth = <ccudart.EGLint><void_ptr>pwidth
-
-    cdef ccudart.EGLStreamKHR ceglStream
-    if eglStream is None:
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>0
-    elif isinstance(eglStream, (EGLStreamKHR)):
-        peglStream = int(eglStream)
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
+        ptarget = int(GLenum(target))
+        cytarget = <cyruntime.GLenum><void_ptr>ptarget
+    cdef cyruntime.GLuint cyimage
+    if image is None:
+        cyimage = <cyruntime.GLuint><void_ptr>0
+    elif isinstance(image, (GLuint,)):
+        pimage = int(image)
+        cyimage = <cyruntime.GLuint><void_ptr>pimage
     else:
-        peglStream = int(EGLStreamKHR(eglStream))
-        ceglStream = <ccudart.EGLStreamKHR><void_ptr>peglStream
-
-    cdef cudaEglStreamConnection conn = cudaEglStreamConnection()
-    err = ccudart.cudaEGLStreamProducerConnect(<ccudart.cudaEglStreamConnection*>conn._ptr, ceglStream, cwidth, cheight)
-    return (cudaError_t(err), conn)
+        pimage = int(GLuint(image))
+        cyimage = <cyruntime.GLuint><void_ptr>pimage
+    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
+    err = cyruntime.cudaGraphicsGLRegisterImage(resource._ptr, cyimage, cytarget, flags)
+    return (cudaError_t(err), resource)
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerDisconnect' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEGLStreamProducerDisconnect(conn):
-    """ Disconnect CUDA as a producer to EGLStream .
+def cudaGraphicsGLRegisterBuffer(buffer, unsigned int flags):
+    """ Registers an OpenGL buffer object.
 
-    Disconnect CUDA as a producer to EGLStreamKHR.
+    Registers the buffer object specified by `buffer` for access by CUDA. A
+    handle to the registered object is returned as `resource`. The register
+    flags `flags` specify the intended usage, as follows:
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsNone`: Specifies no hints about
+      how this resource will be used. It is therefore assumed that this
+      resource will be read from and written to by CUDA. This is the
+      default value.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsReadOnly`: Specifies that CUDA
+      will not write to this resource.
+
+    - :py:obj:`~.cudaGraphicsRegisterFlagsWriteDiscard`: Specifies that
+      CUDA will not read from this resource and will write over the entire
+      contents of the resource, so none of the data previously stored in
+      the resource will be preserved.
 
     Parameters
     ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Conection to disconnect.
+    buffer : :py:obj:`~.GLuint`
+        name of buffer object to be registered
+    flags : unsigned int
+        Register flags
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
+    resource : :py:obj:`~.cudaGraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerDisconnect`
+    :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsMapResources`, :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsGLRegisterBuffer`
     """
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
+    cdef cyruntime.GLuint cybuffer
+    if buffer is None:
+        cybuffer = <cyruntime.GLuint><void_ptr>0
+    elif isinstance(buffer, (GLuint,)):
+        pbuffer = int(buffer)
+        cybuffer = <cyruntime.GLuint><void_ptr>pbuffer
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccudart.cudaEGLStreamProducerDisconnect(cconn)
-    return (cudaError_t(err),)
+        pbuffer = int(GLuint(buffer))
+        cybuffer = <cyruntime.GLuint><void_ptr>pbuffer
+    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
+    err = cyruntime.cudaGraphicsGLRegisterBuffer(resource._ptr, cybuffer, flags)
+    return (cudaError_t(err), resource)
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerPresentFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEGLStreamProducerPresentFrame(conn, eglframe not None : cudaEglFrame, pStream):
-    """ Present a CUDA eglFrame to the EGLStream with CUDA as a producer.
-
-    The :py:obj:`~.cudaEglFrame` is defined as:
-
-    **View CUDA Toolkit Documentation for a C++ code example**
+def cudaVDPAUGetDevice(vdpDevice, vdpGetProcAddress):
+    """ Gets the CUDA device associated with a VdpDevice.
 
-    For :py:obj:`~.cudaEglFrame` of type :py:obj:`~.cudaEglFrameTypePitch`,
-    the application may present sub-region of a memory allocation. In that
-    case, :py:obj:`~.cudaPitchedPtr.ptr` will specify the start address of
-    the sub-region in the allocation and :py:obj:`~.cudaEglPlaneDesc` will
-    specify the dimensions of the sub-region.
+    Returns the CUDA device associated with a VdpDevice, if applicable.
 
     Parameters
     ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Connection on which to present the CUDA array
-    eglframe : :py:obj:`~.cudaEglFrame`
-        CUDA Eglstream Proucer Frame handle to be sent to the consumer over
-        EglStream.
-    pStream : :py:obj:`~.cudaStream_t`
-        CUDA stream on which to present the frame.
+    vdpDevice : :py:obj:`~.VdpDevice`
+        A VdpDevice handle
+    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
+        VDPAU's VdpGetProcAddress function pointer
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+        :py:obj:`~.cudaSuccess`
+    device : int
+        Returns the device associated with vdpDevice, or -1 if the device
+        associated with vdpDevice is not a compute device.
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerReturnFrame`, :py:obj:`~.cuEGLStreamProducerPresentFrame`
+    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cuVDPAUGetDevice`
     """
-    cdef ccudart.cudaStream_t *cpStream
-    if pStream is None:
-        cpStream = <ccudart.cudaStream_t*><void_ptr>NULL
-    elif isinstance(pStream, (cudaStream_t,cuda.CUstream)):
-        ppStream = pStream.getPtr()
-        cpStream = <ccudart.cudaStream_t*><void_ptr>ppStream
-    elif isinstance(pStream, (int)):
-        cpStream = <ccudart.cudaStream_t*><void_ptr>pStream
+    cdef cyruntime.VdpGetProcAddress *cyvdpGetProcAddress
+    if vdpGetProcAddress is None:
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>NULL
+    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress,)):
+        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
+    elif isinstance(vdpGetProcAddress, (int)):
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cudart.cudaStream_t,cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
+        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, runtime.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
+    cdef cyruntime.VdpDevice cyvdpDevice
+    if vdpDevice is None:
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>0
+    elif isinstance(vdpDevice, (VdpDevice,)):
+        pvdpDevice = int(vdpDevice)
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    err = ccudart.cudaEGLStreamProducerPresentFrame(cconn, eglframe._ptr[0], cpStream)
-    return (cudaError_t(err),)
+        pvdpDevice = int(VdpDevice(vdpDevice))
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
+    cdef int device = 0
+    err = cyruntime.cudaVDPAUGetDevice(&device, cyvdpDevice, cyvdpGetProcAddress)
+    return (cudaError_t(err), device)
 {{endif}}
 
-{{if True or 'cudaEGLStreamProducerReturnFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEGLStreamProducerReturnFrame(conn, eglframe : Optional[cudaEglFrame], pStream):
-    """ Return the CUDA eglFrame to the EGLStream last released by the consumer.
+def cudaVDPAUSetVDPAUDevice(int device, vdpDevice, vdpGetProcAddress):
+    """ Sets a CUDA device to use VDPAU interoperability.
 
-    This API can potentially return cudaErrorLaunchTimeout if the consumer
-    has not returned a frame to EGL stream. If timeout is returned the
-    application can retry.
+    Records `vdpDevice` as the VdpDevice for VDPAU interoperability with
+    the CUDA device `device` and sets `device` as the current device for
+    the calling host thread.
+
+    If `device` has already been initialized then this call will fail with
+    the error :py:obj:`~.cudaErrorSetOnActiveProcess`. In this case it is
+    necessary to reset `device` using :py:obj:`~.cudaDeviceReset()` before
+    VDPAU interoperability on `device` may be enabled.
 
     Parameters
     ----------
-    conn : :py:obj:`~.cudaEglStreamConnection`
-        Connection on which to present the CUDA array
-    eglframe : :py:obj:`~.cudaEglFrame`
-        CUDA Eglstream Proucer Frame handle returned from the consumer over
-        EglStream.
-    pStream : :py:obj:`~.cudaStream_t`
-        CUDA stream on which to return the frame.
+    device : int
+        Device to use for VDPAU interoperability
+    vdpDevice : :py:obj:`~.VdpDevice`
+        The VdpDevice to interoperate with
+    vdpGetProcAddress : :py:obj:`~.VdpGetProcAddress`
+        VDPAU's VdpGetProcAddress function pointer
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorLaunchTimeout`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorSetOnActiveProcess`
 
     See Also
     --------
-    :py:obj:`~.cudaEGLStreamProducerConnect`, :py:obj:`~.cudaEGLStreamProducerDisconnect`, :py:obj:`~.cudaEGLStreamProducerPresentFrame`, :py:obj:`~.cuEGLStreamProducerReturnFrame`
+    :py:obj:`~.cudaGraphicsVDPAURegisterVideoSurface`, :py:obj:`~.cudaGraphicsVDPAURegisterOutputSurface`, :py:obj:`~.cudaDeviceReset`
     """
-    cdef ccudart.cudaStream_t *cpStream
-    if pStream is None:
-        cpStream = <ccudart.cudaStream_t*><void_ptr>NULL
-    elif isinstance(pStream, (cudaStream_t,cuda.CUstream)):
-        ppStream = pStream.getPtr()
-        cpStream = <ccudart.cudaStream_t*><void_ptr>ppStream
-    elif isinstance(pStream, (int)):
-        cpStream = <ccudart.cudaStream_t*><void_ptr>pStream
+    cdef cyruntime.VdpGetProcAddress *cyvdpGetProcAddress
+    if vdpGetProcAddress is None:
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>NULL
+    elif isinstance(vdpGetProcAddress, (VdpGetProcAddress,)):
+        pvdpGetProcAddress = vdpGetProcAddress.getPtr()
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>pvdpGetProcAddress
+    elif isinstance(vdpGetProcAddress, (int)):
+        cyvdpGetProcAddress = <cyruntime.VdpGetProcAddress*><void_ptr>vdpGetProcAddress
     else:
-        raise TypeError("Argument 'pStream' is not instance of type (expected <class 'int, cudart.cudaStream_t,cuda.CUstream'>, found " + str(type(pStream)))
-
-    cdef ccudart.cudaEglStreamConnection *cconn
-    if conn is None:
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>NULL
-    elif isinstance(conn, (cudaEglStreamConnection,cuda.CUeglStreamConnection)):
-        pconn = conn.getPtr()
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>pconn
-    elif isinstance(conn, (int)):
-        cconn = <ccudart.cudaEglStreamConnection*><void_ptr>conn
+        raise TypeError("Argument 'vdpGetProcAddress' is not instance of type (expected <class 'int, runtime.VdpGetProcAddress'>, found " + str(type(vdpGetProcAddress)))
+    cdef cyruntime.VdpDevice cyvdpDevice
+    if vdpDevice is None:
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>0
+    elif isinstance(vdpDevice, (VdpDevice,)):
+        pvdpDevice = int(vdpDevice)
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
     else:
-        raise TypeError("Argument 'conn' is not instance of type (expected <class 'int, cudart.cudaEglStreamConnection,cuda.CUeglStreamConnection'>, found " + str(type(conn)))
-
-    cdef ccudart.cudaEglFrame* ceglframe_ptr = eglframe._ptr if eglframe != None else NULL
-    err = ccudart.cudaEGLStreamProducerReturnFrame(cconn, ceglframe_ptr, cpStream)
+        pvdpDevice = int(VdpDevice(vdpDevice))
+        cyvdpDevice = <cyruntime.VdpDevice><void_ptr>pvdpDevice
+    err = cyruntime.cudaVDPAUSetVDPAUDevice(device, cyvdpDevice, cyvdpGetProcAddress)
     return (cudaError_t(err),)
 {{endif}}
 
-{{if True or 'cudaGraphicsResourceGetMappedEglFrame' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaGraphicsResourceGetMappedEglFrame(resource, unsigned int index, unsigned int mipLevel):
-    """ Get an eglFrame through which to access a registered EGL graphics resource.
+def cudaGraphicsVDPAURegisterVideoSurface(vdpSurface, unsigned int flags):
+    """ Register a VdpVideoSurface object.
 
-    Returns in `*eglFrame` an eglFrame pointer through which the registered
-    graphics resource `resource` may be accessed. This API can only be
-    called for EGL graphics resources.
+    Registers the VdpVideoSurface specified by `vdpSurface` for access by
+    CUDA. A handle to the registered object is returned as `resource`. The
+    surface's intended usage is specified using `flags`, as follows:
 
-    The :py:obj:`~.cudaEglFrame` is defined as
+    - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how
+      this resource will be used. It is therefore assumed that this
+      resource will be read from and written to by CUDA. This is the
+      default value.
 
-    **View CUDA Toolkit Documentation for a C++ code example**
+    - :py:obj:`~.cudaGraphicsMapFlagsReadOnly`: Specifies that CUDA will
+      not write to this resource.
+
+    - :py:obj:`~.cudaGraphicsMapFlagsWriteDiscard`: Specifies that CUDA
+      will not read from this resource and will write over the entire
+      contents of the resource, so none of the data previously stored in
+      the resource will be preserved.
 
     Parameters
     ----------
-    resource : :py:obj:`~.cudaGraphicsResource_t`
-        Registered resource to access.
-    index : unsigned int
-        Index for cubemap surfaces.
-    mipLevel : unsigned int
-        Mipmap level for the subresource to access.
+    vdpSurface : :py:obj:`~.VdpVideoSurface`
+        VDPAU object to be registered
+    flags : unsigned int
+        Map flags
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorUnknown`
-    eglFrame : :py:obj:`~.cudaEglFrame`
-        Returned eglFrame.
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
+    resource : :py:obj:`~.cudaGraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cudaGraphicsResourceGetMappedPointer`, :py:obj:`~.cuGraphicsResourceGetMappedEglFrame`
-
-    Notes
-    -----
-    Note that in case of multiplanar `*eglFrame`, pitch of only first plane (unsigned int :py:obj:`~.cudaEglPlaneDesc.pitch`) is to be considered by the application.
+    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsVDPAURegisterVideoSurface`
     """
-    cdef ccudart.cudaGraphicsResource_t cresource
-    if resource is None:
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>0
-    elif isinstance(resource, (cudaGraphicsResource_t)):
-        presource = int(resource)
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
+    cdef cyruntime.VdpVideoSurface cyvdpSurface
+    if vdpSurface is None:
+        cyvdpSurface = <cyruntime.VdpVideoSurface><void_ptr>0
+    elif isinstance(vdpSurface, (VdpVideoSurface,)):
+        pvdpSurface = int(vdpSurface)
+        cyvdpSurface = <cyruntime.VdpVideoSurface><void_ptr>pvdpSurface
     else:
-        presource = int(cudaGraphicsResource_t(resource))
-        cresource = <ccudart.cudaGraphicsResource_t><void_ptr>presource
-
-    cdef cudaEglFrame eglFrame = cudaEglFrame()
-    err = ccudart.cudaGraphicsResourceGetMappedEglFrame(eglFrame._ptr, cresource, index, mipLevel)
-    return (cudaError_t(err), eglFrame)
+        pvdpSurface = int(VdpVideoSurface(vdpSurface))
+        cyvdpSurface = <cyruntime.VdpVideoSurface><void_ptr>pvdpSurface
+    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
+    err = cyruntime.cudaGraphicsVDPAURegisterVideoSurface(resource._ptr, cyvdpSurface, flags)
+    return (cudaError_t(err), resource)
 {{endif}}
 
-{{if True or 'cudaEventCreateFromEGLSync' in found_functions}}
+{{if True}}
 
 @cython.embedsignature(True)
-def cudaEventCreateFromEGLSync(eglSync, unsigned int flags):
-    """ Creates an event from EGLSync object.
-
-    Creates an event *phEvent from an EGLSyncKHR eglSync with the flages
-    specified via `flags`. Valid flags include:
+def cudaGraphicsVDPAURegisterOutputSurface(vdpSurface, unsigned int flags):
+    """ Register a VdpOutputSurface object.
 
-    - :py:obj:`~.cudaEventDefault`: Default event creation flag.
+    Registers the VdpOutputSurface specified by `vdpSurface` for access by
+    CUDA. A handle to the registered object is returned as `resource`. The
+    surface's intended usage is specified using `flags`, as follows:
 
-    - :py:obj:`~.cudaEventBlockingSync`: Specifies that the created event
-      should use blocking synchronization. A CPU thread that uses
-      :py:obj:`~.cudaEventSynchronize()` to wait on an event created with
-      this flag will block until the event has actually been completed.
+    - :py:obj:`~.cudaGraphicsMapFlagsNone`: Specifies no hints about how
+      this resource will be used. It is therefore assumed that this
+      resource will be read from and written to by CUDA. This is the
+      default value.
 
-    :py:obj:`~.cudaEventRecord` and TimingData are not supported for events
-    created from EGLSync.
+    - :py:obj:`~.cudaGraphicsMapFlagsReadOnly`: Specifies that CUDA will
+      not write to this resource.
 
-    The EGLSyncKHR is an opaque handle to an EGL sync object. typedef void*
-    EGLSyncKHR
+    - :py:obj:`~.cudaGraphicsMapFlagsWriteDiscard`: Specifies that CUDA
+      will not read from this resource and will write over the entire
+      contents of the resource, so none of the data previously stored in
+      the resource will be preserved.
 
     Parameters
     ----------
-    eglSync : :py:obj:`~.EGLSyncKHR`
-        Opaque handle to EGLSync object
+    vdpSurface : :py:obj:`~.VdpOutputSurface`
+        VDPAU object to be registered
     flags : unsigned int
-        Event creation flags
+        Map flags
 
     Returns
     -------
     cudaError_t
-        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInitializationError`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorLaunchFailure`, :py:obj:`~.cudaErrorMemoryAllocation`
-    phEvent : :py:obj:`~.cudaEvent_t`
-        Returns newly created event
+        :py:obj:`~.cudaSuccess`, :py:obj:`~.cudaErrorInvalidDevice`, :py:obj:`~.cudaErrorInvalidValue`, :py:obj:`~.cudaErrorInvalidResourceHandle`, :py:obj:`~.cudaErrorUnknown`
+    resource : :py:obj:`~.cudaGraphicsResource`
+        Pointer to the returned object handle
 
     See Also
     --------
-    :py:obj:`~.cudaEventQuery`, :py:obj:`~.cudaEventSynchronize`, :py:obj:`~.cudaEventDestroy`
+    :py:obj:`~.cudaVDPAUSetVDPAUDevice`, :py:obj:`~.cudaGraphicsUnregisterResource`, :py:obj:`~.cudaGraphicsSubResourceGetMappedArray`, :py:obj:`~.cuGraphicsVDPAURegisterOutputSurface`
     """
-    cdef ccudart.EGLSyncKHR ceglSync
-    if eglSync is None:
-        ceglSync = <ccudart.EGLSyncKHR><void_ptr>0
-    elif isinstance(eglSync, (EGLSyncKHR)):
-        peglSync = int(eglSync)
-        ceglSync = <ccudart.EGLSyncKHR><void_ptr>peglSync
+    cdef cyruntime.VdpOutputSurface cyvdpSurface
+    if vdpSurface is None:
+        cyvdpSurface = <cyruntime.VdpOutputSurface><void_ptr>0
+    elif isinstance(vdpSurface, (VdpOutputSurface,)):
+        pvdpSurface = int(vdpSurface)
+        cyvdpSurface = <cyruntime.VdpOutputSurface><void_ptr>pvdpSurface
     else:
-        peglSync = int(EGLSyncKHR(eglSync))
-        ceglSync = <ccudart.EGLSyncKHR><void_ptr>peglSync
-
-    cdef cudaEvent_t phEvent = cudaEvent_t()
-    err = ccudart.cudaEventCreateFromEGLSync(<ccudart.cudaEvent_t*>phEvent._ptr, ceglSync, flags)
-    return (cudaError_t(err), phEvent)
+        pvdpSurface = int(VdpOutputSurface(vdpSurface))
+        cyvdpSurface = <cyruntime.VdpOutputSurface><void_ptr>pvdpSurface
+    cdef cudaGraphicsResource_t resource = cudaGraphicsResource_t()
+    err = cyruntime.cudaGraphicsVDPAURegisterOutputSurface(resource._ptr, cyvdpSurface, flags)
+    return (cudaError_t(err), resource)
 {{endif}}
 
 
@@ -26832,7 +26944,7 @@ def getLocalRuntimeVersion():
     :py:obj:`~.cudaDriverGetVersion`, :py:obj:`~.cuDriverGetVersion`
     """
     cdef int runtimeVersion = 0
-    err = ccudart.getLocalRuntimeVersion(&runtimeVersion)
+    err = cyruntime.getLocalRuntimeVersion(&runtimeVersion)
     return (cudaError_t(err), runtimeVersion)
 
 
@@ -26850,241 +26962,241 @@ def sizeof(objType):
     lowered_name : int
         The size of `objType` in bytes
     """
-    {{if 'dim3' in found_types}}
+    {{if 'struct dim3' in found_types}}
     if objType == dim3:
-        return sizeof(ccudart.dim3){{endif}}
-    {{if True or 'cudaChannelFormatDesc' in found_types}}
+        return sizeof(cyruntime.dim3){{endif}}
+    {{if 'struct cudaChannelFormatDesc' in found_types}}
     if objType == cudaChannelFormatDesc:
-        return sizeof(ccudart.cudaChannelFormatDesc){{endif}}
-    {{if 'cudaArraySparseProperties' in found_types}}
+        return sizeof(cyruntime.cudaChannelFormatDesc){{endif}}
+    {{if 'cudaArray_t' in found_types}}
+    if objType == cudaArray_t:
+        return sizeof(cyruntime.cudaArray_t){{endif}}
+    {{if 'cudaArray_const_t' in found_types}}
+    if objType == cudaArray_const_t:
+        return sizeof(cyruntime.cudaArray_const_t){{endif}}
+    {{if 'cudaMipmappedArray_t' in found_types}}
+    if objType == cudaMipmappedArray_t:
+        return sizeof(cyruntime.cudaMipmappedArray_t){{endif}}
+    {{if 'cudaMipmappedArray_const_t' in found_types}}
+    if objType == cudaMipmappedArray_const_t:
+        return sizeof(cyruntime.cudaMipmappedArray_const_t){{endif}}
+    {{if 'struct cudaArraySparseProperties' in found_types}}
     if objType == cudaArraySparseProperties:
-        return sizeof(ccudart.cudaArraySparseProperties){{endif}}
-    {{if 'cudaArrayMemoryRequirements' in found_types}}
+        return sizeof(cyruntime.cudaArraySparseProperties){{endif}}
+    {{if 'struct cudaArrayMemoryRequirements' in found_types}}
     if objType == cudaArrayMemoryRequirements:
-        return sizeof(ccudart.cudaArrayMemoryRequirements){{endif}}
-    {{if True or 'cudaPitchedPtr' in found_types}}
+        return sizeof(cyruntime.cudaArrayMemoryRequirements){{endif}}
+    {{if 'struct cudaPitchedPtr' in found_types}}
     if objType == cudaPitchedPtr:
-        return sizeof(ccudart.cudaPitchedPtr){{endif}}
-    {{if 'cudaExtent' in found_types}}
+        return sizeof(cyruntime.cudaPitchedPtr){{endif}}
+    {{if 'struct cudaExtent' in found_types}}
     if objType == cudaExtent:
-        return sizeof(ccudart.cudaExtent){{endif}}
-    {{if 'cudaPos' in found_types}}
+        return sizeof(cyruntime.cudaExtent){{endif}}
+    {{if 'struct cudaPos' in found_types}}
     if objType == cudaPos:
-        return sizeof(ccudart.cudaPos){{endif}}
-    {{if 'cudaMemcpy3DParms' in found_types}}
+        return sizeof(cyruntime.cudaPos){{endif}}
+    {{if 'struct cudaMemcpy3DParms' in found_types}}
     if objType == cudaMemcpy3DParms:
-        return sizeof(ccudart.cudaMemcpy3DParms){{endif}}
-    {{if 'cudaMemcpy3DPeerParms' in found_types}}
+        return sizeof(cyruntime.cudaMemcpy3DParms){{endif}}
+    {{if 'struct cudaMemcpy3DPeerParms' in found_types}}
     if objType == cudaMemcpy3DPeerParms:
-        return sizeof(ccudart.cudaMemcpy3DPeerParms){{endif}}
-    {{if 'cudaMemsetParams' in found_types}}
+        return sizeof(cyruntime.cudaMemcpy3DPeerParms){{endif}}
+    {{if 'struct cudaMemsetParams' in found_types}}
     if objType == cudaMemsetParams:
-        return sizeof(ccudart.cudaMemsetParams){{endif}}
-    {{if 'cudaAccessPolicyWindow' in found_types}}
+        return sizeof(cyruntime.cudaMemsetParams){{endif}}
+    {{if 'struct cudaAccessPolicyWindow' in found_types}}
     if objType == cudaAccessPolicyWindow:
-        return sizeof(ccudart.cudaAccessPolicyWindow){{endif}}
-    {{if 'cudaHostNodeParams' in found_types}}
+        return sizeof(cyruntime.cudaAccessPolicyWindow){{endif}}
+    {{if 'cudaHostFn_t' in found_types}}
+    if objType == cudaHostFn_t:
+        return sizeof(cyruntime.cudaHostFn_t){{endif}}
+    {{if 'struct cudaHostNodeParams' in found_types}}
     if objType == cudaHostNodeParams:
-        return sizeof(ccudart.cudaHostNodeParams){{endif}}
-    {{if 'cudaResourceDesc' in found_types}}
+        return sizeof(cyruntime.cudaHostNodeParams){{endif}}
+    {{if 'struct cudaResourceDesc' in found_types}}
     if objType == cudaResourceDesc:
-        return sizeof(ccudart.cudaResourceDesc){{endif}}
-    {{if 'cudaResourceViewDesc' in found_types}}
+        return sizeof(cyruntime.cudaResourceDesc){{endif}}
+    {{if 'struct cudaResourceViewDesc' in found_types}}
     if objType == cudaResourceViewDesc:
-        return sizeof(ccudart.cudaResourceViewDesc){{endif}}
-    {{if 'cudaPointerAttributes' in found_types}}
+        return sizeof(cyruntime.cudaResourceViewDesc){{endif}}
+    {{if 'struct cudaPointerAttributes' in found_types}}
     if objType == cudaPointerAttributes:
-        return sizeof(ccudart.cudaPointerAttributes){{endif}}
-    {{if 'cudaFuncAttributes' in found_types}}
+        return sizeof(cyruntime.cudaPointerAttributes){{endif}}
+    {{if 'struct cudaFuncAttributes' in found_types}}
     if objType == cudaFuncAttributes:
-        return sizeof(ccudart.cudaFuncAttributes){{endif}}
-    {{if 'cudaMemLocation' in found_types}}
+        return sizeof(cyruntime.cudaFuncAttributes){{endif}}
+    {{if 'struct cudaMemLocation' in found_types}}
     if objType == cudaMemLocation:
-        return sizeof(ccudart.cudaMemLocation){{endif}}
-    {{if 'cudaMemAccessDesc' in found_types}}
+        return sizeof(cyruntime.cudaMemLocation){{endif}}
+    {{if 'struct cudaMemAccessDesc' in found_types}}
     if objType == cudaMemAccessDesc:
-        return sizeof(ccudart.cudaMemAccessDesc){{endif}}
-    {{if 'cudaMemPoolProps' in found_types}}
+        return sizeof(cyruntime.cudaMemAccessDesc){{endif}}
+    {{if 'struct cudaMemPoolProps' in found_types}}
     if objType == cudaMemPoolProps:
-        return sizeof(ccudart.cudaMemPoolProps){{endif}}
-    {{if 'cudaMemPoolPtrExportData' in found_types}}
+        return sizeof(cyruntime.cudaMemPoolProps){{endif}}
+    {{if 'struct cudaMemPoolPtrExportData' in found_types}}
     if objType == cudaMemPoolPtrExportData:
-        return sizeof(ccudart.cudaMemPoolPtrExportData){{endif}}
-    {{if 'cudaMemAllocNodeParams' in found_types}}
+        return sizeof(cyruntime.cudaMemPoolPtrExportData){{endif}}
+    {{if 'struct cudaMemAllocNodeParams' in found_types}}
     if objType == cudaMemAllocNodeParams:
-        return sizeof(ccudart.cudaMemAllocNodeParams){{endif}}
-    {{if 'CUuuid_st' in found_types}}
+        return sizeof(cyruntime.cudaMemAllocNodeParams){{endif}}
+    {{if 'struct CUuuid_st' in found_types}}
     if objType == CUuuid_st:
-        return sizeof(ccudart.CUuuid_st){{endif}}
-    {{if 'cudaDeviceProp' in found_types}}
+        return sizeof(cyruntime.CUuuid_st){{endif}}
+    {{if 'CUuuid' in found_types}}
+    if objType == CUuuid:
+        return sizeof(cyruntime.CUuuid){{endif}}
+    {{if 'cudaUUID_t' in found_types}}
+    if objType == cudaUUID_t:
+        return sizeof(cyruntime.cudaUUID_t){{endif}}
+    {{if 'struct cudaDeviceProp' in found_types}}
     if objType == cudaDeviceProp:
-        return sizeof(ccudart.cudaDeviceProp){{endif}}
-    {{if 'cudaIpcEventHandle_st' in found_types}}
+        return sizeof(cyruntime.cudaDeviceProp){{endif}}
+    {{if 'struct cudaIpcEventHandle_st' in found_types}}
     if objType == cudaIpcEventHandle_st:
-        return sizeof(ccudart.cudaIpcEventHandle_st){{endif}}
-    {{if 'cudaIpcMemHandle_st' in found_types}}
+        return sizeof(cyruntime.cudaIpcEventHandle_st){{endif}}
+    {{if 'cudaIpcEventHandle_t' in found_types}}
+    if objType == cudaIpcEventHandle_t:
+        return sizeof(cyruntime.cudaIpcEventHandle_t){{endif}}
+    {{if 'struct cudaIpcMemHandle_st' in found_types}}
     if objType == cudaIpcMemHandle_st:
-        return sizeof(ccudart.cudaIpcMemHandle_st){{endif}}
-    {{if 'cudaExternalMemoryHandleDesc' in found_types}}
+        return sizeof(cyruntime.cudaIpcMemHandle_st){{endif}}
+    {{if 'cudaIpcMemHandle_t' in found_types}}
+    if objType == cudaIpcMemHandle_t:
+        return sizeof(cyruntime.cudaIpcMemHandle_t){{endif}}
+    {{if 'struct cudaExternalMemoryHandleDesc' in found_types}}
     if objType == cudaExternalMemoryHandleDesc:
-        return sizeof(ccudart.cudaExternalMemoryHandleDesc){{endif}}
-    {{if 'cudaExternalMemoryBufferDesc' in found_types}}
+        return sizeof(cyruntime.cudaExternalMemoryHandleDesc){{endif}}
+    {{if 'struct cudaExternalMemoryBufferDesc' in found_types}}
     if objType == cudaExternalMemoryBufferDesc:
-        return sizeof(ccudart.cudaExternalMemoryBufferDesc){{endif}}
-    {{if 'cudaExternalMemoryMipmappedArrayDesc' in found_types}}
+        return sizeof(cyruntime.cudaExternalMemoryBufferDesc){{endif}}
+    {{if 'struct cudaExternalMemoryMipmappedArrayDesc' in found_types}}
     if objType == cudaExternalMemoryMipmappedArrayDesc:
-        return sizeof(ccudart.cudaExternalMemoryMipmappedArrayDesc){{endif}}
-    {{if 'cudaExternalSemaphoreHandleDesc' in found_types}}
+        return sizeof(cyruntime.cudaExternalMemoryMipmappedArrayDesc){{endif}}
+    {{if 'struct cudaExternalSemaphoreHandleDesc' in found_types}}
     if objType == cudaExternalSemaphoreHandleDesc:
-        return sizeof(ccudart.cudaExternalSemaphoreHandleDesc){{endif}}
-    {{if 'cudaExternalSemaphoreSignalParams' in found_types}}
+        return sizeof(cyruntime.cudaExternalSemaphoreHandleDesc){{endif}}
+    {{if 'struct cudaExternalSemaphoreSignalParams' in found_types}}
     if objType == cudaExternalSemaphoreSignalParams:
-        return sizeof(ccudart.cudaExternalSemaphoreSignalParams){{endif}}
-    {{if 'cudaExternalSemaphoreWaitParams' in found_types}}
+        return sizeof(cyruntime.cudaExternalSemaphoreSignalParams){{endif}}
+    {{if 'struct cudaExternalSemaphoreWaitParams' in found_types}}
     if objType == cudaExternalSemaphoreWaitParams:
-        return sizeof(ccudart.cudaExternalSemaphoreWaitParams){{endif}}
-    {{if 'cudaKernelNodeParams' in found_types}}
-    if objType == cudaKernelNodeParams:
-        return sizeof(ccudart.cudaKernelNodeParams){{endif}}
-    {{if 'cudaExternalSemaphoreSignalNodeParams' in found_types}}
-    if objType == cudaExternalSemaphoreSignalNodeParams:
-        return sizeof(ccudart.cudaExternalSemaphoreSignalNodeParams){{endif}}
-    {{if 'cudaExternalSemaphoreWaitNodeParams' in found_types}}
-    if objType == cudaExternalSemaphoreWaitNodeParams:
-        return sizeof(ccudart.cudaExternalSemaphoreWaitNodeParams){{endif}}
-    {{if True or 'cudaLaunchAttributeValue' in found_types}}
-    if objType == cudaLaunchAttributeValue:
-        return sizeof(ccudart.cudaLaunchAttributeValue){{endif}}
-    {{if 'cudaLaunchAttribute_st' in found_types}}
-    if objType == cudaLaunchAttribute_st:
-        return sizeof(ccudart.cudaLaunchAttribute_st){{endif}}
-    {{if 'cudaTextureDesc' in found_types}}
-    if objType == cudaTextureDesc:
-        return sizeof(ccudart.cudaTextureDesc){{endif}}
-    {{if 'cudaTextureDesc_v2' in found_types}}
-    if objType == cudaTextureDesc_v2:
-        return sizeof(ccudart.cudaTextureDesc_v2){{endif}}
-    {{if True or 'cudaEglPlaneDesc_st' in found_types}}
-    if objType == cudaEglPlaneDesc_st:
-        return sizeof(ccudart.cudaEglPlaneDesc_st){{endif}}
-    {{if True or 'cudaEglFrame_st' in found_types}}
-    if objType == cudaEglFrame_st:
-        return sizeof(ccudart.cudaEglFrame_st){{endif}}
-    {{if 'cudaArray_t' in found_types}}
-    if objType == cudaArray_t:
-        return sizeof(ccudart.cudaArray_t){{endif}}
-    {{if 'cudaArray_const_t' in found_types}}
-    if objType == cudaArray_const_t:
-        return sizeof(ccudart.cudaArray_const_t){{endif}}
-    {{if 'cudaMipmappedArray_t' in found_types}}
-    if objType == cudaMipmappedArray_t:
-        return sizeof(ccudart.cudaMipmappedArray_t){{endif}}
-    {{if 'cudaMipmappedArray_const_t' in found_types}}
-    if objType == cudaMipmappedArray_const_t:
-        return sizeof(ccudart.cudaMipmappedArray_const_t){{endif}}
+        return sizeof(cyruntime.cudaExternalSemaphoreWaitParams){{endif}}
     {{if 'cudaStream_t' in found_types}}
     if objType == cudaStream_t:
-        return sizeof(ccudart.cudaStream_t){{endif}}
+        return sizeof(cyruntime.cudaStream_t){{endif}}
     {{if 'cudaEvent_t' in found_types}}
     if objType == cudaEvent_t:
-        return sizeof(ccudart.cudaEvent_t){{endif}}
+        return sizeof(cyruntime.cudaEvent_t){{endif}}
     {{if 'cudaGraphicsResource_t' in found_types}}
     if objType == cudaGraphicsResource_t:
-        return sizeof(ccudart.cudaGraphicsResource_t){{endif}}
+        return sizeof(cyruntime.cudaGraphicsResource_t){{endif}}
     {{if 'cudaExternalMemory_t' in found_types}}
     if objType == cudaExternalMemory_t:
-        return sizeof(ccudart.cudaExternalMemory_t){{endif}}
+        return sizeof(cyruntime.cudaExternalMemory_t){{endif}}
     {{if 'cudaExternalSemaphore_t' in found_types}}
     if objType == cudaExternalSemaphore_t:
-        return sizeof(ccudart.cudaExternalSemaphore_t){{endif}}
+        return sizeof(cyruntime.cudaExternalSemaphore_t){{endif}}
     {{if 'cudaGraph_t' in found_types}}
     if objType == cudaGraph_t:
-        return sizeof(ccudart.cudaGraph_t){{endif}}
+        return sizeof(cyruntime.cudaGraph_t){{endif}}
     {{if 'cudaGraphNode_t' in found_types}}
     if objType == cudaGraphNode_t:
-        return sizeof(ccudart.cudaGraphNode_t){{endif}}
+        return sizeof(cyruntime.cudaGraphNode_t){{endif}}
     {{if 'cudaUserObject_t' in found_types}}
     if objType == cudaUserObject_t:
-        return sizeof(ccudart.cudaUserObject_t){{endif}}
+        return sizeof(cyruntime.cudaUserObject_t){{endif}}
     {{if 'cudaFunction_t' in found_types}}
     if objType == cudaFunction_t:
-        return sizeof(ccudart.cudaFunction_t){{endif}}
+        return sizeof(cyruntime.cudaFunction_t){{endif}}
     {{if 'cudaMemPool_t' in found_types}}
     if objType == cudaMemPool_t:
-        return sizeof(ccudart.cudaMemPool_t){{endif}}
+        return sizeof(cyruntime.cudaMemPool_t){{endif}}
+    {{if 'struct cudaKernelNodeParams' in found_types}}
+    if objType == cudaKernelNodeParams:
+        return sizeof(cyruntime.cudaKernelNodeParams){{endif}}
+    {{if 'struct cudaExternalSemaphoreSignalNodeParams' in found_types}}
+    if objType == cudaExternalSemaphoreSignalNodeParams:
+        return sizeof(cyruntime.cudaExternalSemaphoreSignalNodeParams){{endif}}
+    {{if 'struct cudaExternalSemaphoreWaitNodeParams' in found_types}}
+    if objType == cudaExternalSemaphoreWaitNodeParams:
+        return sizeof(cyruntime.cudaExternalSemaphoreWaitNodeParams){{endif}}
     {{if 'cudaGraphExec_t' in found_types}}
     if objType == cudaGraphExec_t:
-        return sizeof(ccudart.cudaGraphExec_t){{endif}}
-    {{if True or 'EGLImageKHR' in found_types}}
-    if objType == EGLImageKHR:
-        return sizeof(ccudart.EGLImageKHR){{endif}}
-    {{if True or 'EGLStreamKHR' in found_types}}
-    if objType == EGLStreamKHR:
-        return sizeof(ccudart.EGLStreamKHR){{endif}}
-    {{if True or 'EGLSyncKHR' in found_types}}
-    if objType == EGLSyncKHR:
-        return sizeof(ccudart.EGLSyncKHR){{endif}}
-    {{if True or 'cudaEglStreamConnection' in found_types}}
-    if objType == cudaEglStreamConnection:
-        return sizeof(ccudart.cudaEglStreamConnection){{endif}}
-    {{if 'cudaHostFn_t' in found_types}}
-    if objType == cudaHostFn_t:
-        return sizeof(ccudart.cudaHostFn_t){{endif}}
-    {{if 'cudaStreamCallback_t' in found_types}}
-    if objType == cudaStreamCallback_t:
-        return sizeof(ccudart.cudaStreamCallback_t){{endif}}
-    {{if 'CUuuid' in found_types}}
-    if objType == CUuuid:
-        return sizeof(ccudart.CUuuid){{endif}}
-    {{if 'cudaUUID_t' in found_types}}
-    if objType == cudaUUID_t:
-        return sizeof(ccudart.cudaUUID_t){{endif}}
-    {{if 'cudaIpcEventHandle_t' in found_types}}
-    if objType == cudaIpcEventHandle_t:
-        return sizeof(ccudart.cudaIpcEventHandle_t){{endif}}
-    {{if 'cudaIpcMemHandle_t' in found_types}}
-    if objType == cudaIpcMemHandle_t:
-        return sizeof(ccudart.cudaIpcMemHandle_t){{endif}}
+        return sizeof(cyruntime.cudaGraphExec_t){{endif}}
+    {{if 'union cudaLaunchAttributeValue' in found_types}}
+    if objType == cudaLaunchAttributeValue:
+        return sizeof(cyruntime.cudaLaunchAttributeValue){{endif}}
+    {{if 'struct cudaLaunchAttribute_st' in found_types}}
+    if objType == cudaLaunchAttribute_st:
+        return sizeof(cyruntime.cudaLaunchAttribute_st){{endif}}
     {{if 'cudaLaunchAttribute' in found_types}}
     if objType == cudaLaunchAttribute:
-        return sizeof(ccudart.cudaLaunchAttribute){{endif}}
-    {{if True or 'cudaStreamAttrValue' in found_types}}
-    if objType == cudaStreamAttrValue:
-        return sizeof(ccudart.cudaStreamAttrValue){{endif}}
-    {{if True or 'cudaKernelNodeAttrValue' in found_types}}
-    if objType == cudaKernelNodeAttrValue:
-        return sizeof(ccudart.cudaKernelNodeAttrValue){{endif}}
-    {{if True or 'cudaEglPlaneDesc' in found_types}}
-    if objType == cudaEglPlaneDesc:
-        return sizeof(ccudart.cudaEglPlaneDesc){{endif}}
-    {{if True or 'cudaEglFrame' in found_types}}
-    if objType == cudaEglFrame:
-        return sizeof(ccudart.cudaEglFrame){{endif}}
-    {{if True or 'GLenum' in found_types}}
+        return sizeof(cyruntime.cudaLaunchAttribute){{endif}}
+    {{if 'cudaSurfaceObject_t' in found_types}}
+    if objType == cudaSurfaceObject_t:
+        return sizeof(cyruntime.cudaSurfaceObject_t){{endif}}
+    {{if 'struct cudaTextureDesc' in found_types}}
+    if objType == cudaTextureDesc:
+        return sizeof(cyruntime.cudaTextureDesc){{endif}}
+    {{if 'struct cudaTextureDesc_v2' in found_types}}
+    if objType == cudaTextureDesc_v2:
+        return sizeof(cyruntime.cudaTextureDesc_v2){{endif}}
+    {{if 'cudaTextureObject_t' in found_types}}
+    if objType == cudaTextureObject_t:
+        return sizeof(cyruntime.cudaTextureObject_t){{endif}}
+    {{if 'cudaStreamCallback_t' in found_types}}
+    if objType == cudaStreamCallback_t:
+        return sizeof(cyruntime.cudaStreamCallback_t){{endif}}
+    {{if True}}
     if objType == GLenum:
-        return sizeof(ccudart.GLenum){{endif}}
-    {{if True or 'GLuint' in found_types}}
+        return sizeof(cyruntime.GLenum){{endif}}
+    {{if True}}
     if objType == GLuint:
-        return sizeof(ccudart.GLuint){{endif}}
-    {{if True or 'EGLint' in found_types}}
+        return sizeof(cyruntime.GLuint){{endif}}
+    {{if True}}
+    if objType == EGLImageKHR:
+        return sizeof(cyruntime.EGLImageKHR){{endif}}
+    {{if True}}
+    if objType == EGLStreamKHR:
+        return sizeof(cyruntime.EGLStreamKHR){{endif}}
+    {{if True}}
     if objType == EGLint:
-        return sizeof(ccudart.EGLint){{endif}}
-    {{if True or 'VdpDevice' in found_types}}
+        return sizeof(cyruntime.EGLint){{endif}}
+    {{if True}}
+    if objType == EGLSyncKHR:
+        return sizeof(cyruntime.EGLSyncKHR){{endif}}
+    {{if True}}
     if objType == VdpDevice:
-        return sizeof(ccudart.VdpDevice){{endif}}
-    {{if True or 'VdpGetProcAddress' in found_types}}
+        return sizeof(cyruntime.VdpDevice){{endif}}
+    {{if True}}
     if objType == VdpGetProcAddress:
-        return sizeof(ccudart.VdpGetProcAddress){{endif}}
-    {{if True or 'VdpVideoSurface' in found_types}}
+        return sizeof(cyruntime.VdpGetProcAddress){{endif}}
+    {{if True}}
     if objType == VdpVideoSurface:
-        return sizeof(ccudart.VdpVideoSurface){{endif}}
-    {{if True or 'VdpOutputSurface' in found_types}}
+        return sizeof(cyruntime.VdpVideoSurface){{endif}}
+    {{if True}}
     if objType == VdpOutputSurface:
-        return sizeof(ccudart.VdpOutputSurface){{endif}}
-    {{if 'cudaSurfaceObject_t' in found_types}}
-    if objType == cudaSurfaceObject_t:
-        return sizeof(ccudart.cudaSurfaceObject_t){{endif}}
-    {{if 'cudaTextureObject_t' in found_types}}
-    if objType == cudaTextureObject_t:
-        return sizeof(ccudart.cudaTextureObject_t){{endif}}
+        return sizeof(cyruntime.VdpOutputSurface){{endif}}
+    {{if True}}
+    if objType == cudaStreamAttrValue:
+        return sizeof(cyruntime.cudaStreamAttrValue){{endif}}
+    {{if True}}
+    if objType == cudaKernelNodeAttrValue:
+        return sizeof(cyruntime.cudaKernelNodeAttrValue){{endif}}
+    {{if True}}
+    if objType == cudaEglPlaneDesc_st:
+        return sizeof(cyruntime.cudaEglPlaneDesc_st){{endif}}
+    {{if True}}
+    if objType == cudaEglPlaneDesc:
+        return sizeof(cyruntime.cudaEglPlaneDesc){{endif}}
+    {{if True}}
+    if objType == cudaEglFrame_st:
+        return sizeof(cyruntime.cudaEglFrame_st){{endif}}
+    {{if True}}
+    if objType == cudaEglFrame:
+        return sizeof(cyruntime.cudaEglFrame){{endif}}
+    {{if True}}
+    if objType == cudaEglStreamConnection:
+        return sizeof(cyruntime.cudaEglStreamConnection){{endif}}
     raise TypeError("Unknown type: " + str(objType))
diff --git a/cuda/cuda/bindings/tests/__init__.py b/cuda/cuda/bindings/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/cuda/tests/test_ccuda.pyx b/cuda/cuda/bindings/tests/test_ccuda.pyx
similarity index 100%
rename from cuda/tests/test_ccuda.pyx
rename to cuda/cuda/bindings/tests/test_ccuda.pyx
diff --git a/cuda/tests/test_ccudart.pyx b/cuda/cuda/bindings/tests/test_ccudart.pyx
similarity index 100%
rename from cuda/tests/test_ccudart.pyx
rename to cuda/cuda/bindings/tests/test_ccudart.pyx
diff --git a/cuda/tests/test_cuda.py b/cuda/cuda/bindings/tests/test_cuda.py
similarity index 100%
rename from cuda/tests/test_cuda.py
rename to cuda/cuda/bindings/tests/test_cuda.py
diff --git a/cuda/tests/test_cudart.py b/cuda/cuda/bindings/tests/test_cudart.py
similarity index 100%
rename from cuda/tests/test_cudart.py
rename to cuda/cuda/bindings/tests/test_cudart.py
diff --git a/cuda/tests/test_cython.py b/cuda/cuda/bindings/tests/test_cython.py
similarity index 85%
rename from cuda/tests/test_cython.py
rename to cuda/cuda/bindings/tests/test_cython.py
index 265758aa..e1f68e1c 100644
--- a/cuda/tests/test_cython.py
+++ b/cuda/cuda/bindings/tests/test_cython.py
@@ -22,9 +22,9 @@ def wrapped(*args, **kwargs):
     return wrapped
 
 
-cython_test_modules = ["cuda.tests.test_ccuda",
-                       "cuda.tests.test_ccudart",
-                       "cuda.tests.test_interoperability_cython"]
+cython_test_modules = ["cuda.bindings.tests.test_ccuda",
+                       "cuda.bindings.tests.test_ccudart",
+                       "cuda.bindings.tests.test_interoperability_cython"]
 
 
 for mod in cython_test_modules:
diff --git a/cuda/tests/test_interoperability.py b/cuda/cuda/bindings/tests/test_interoperability.py
similarity index 100%
rename from cuda/tests/test_interoperability.py
rename to cuda/cuda/bindings/tests/test_interoperability.py
diff --git a/cuda/tests/test_interoperability_cython.pyx b/cuda/cuda/bindings/tests/test_interoperability_cython.pyx
similarity index 100%
rename from cuda/tests/test_interoperability_cython.pyx
rename to cuda/cuda/bindings/tests/test_interoperability_cython.pyx
diff --git a/cuda/tests/test_kernelParams.py b/cuda/cuda/bindings/tests/test_kernelParams.py
similarity index 100%
rename from cuda/tests/test_kernelParams.py
rename to cuda/cuda/bindings/tests/test_kernelParams.py
diff --git a/cuda/tests/test_nvrtc.py b/cuda/cuda/bindings/tests/test_nvrtc.py
similarity index 100%
rename from cuda/tests/test_nvrtc.py
rename to cuda/cuda/bindings/tests/test_nvrtc.py
diff --git a/cuda/cuda/ccuda.pxd b/cuda/cuda/ccuda.pxd
new file mode 100644
index 00000000..73f3fc5c
--- /dev/null
+++ b/cuda/cuda/ccuda.pxd
@@ -0,0 +1,7 @@
+from cuda.bindings.cydriver cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.ccuda module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cydriver module instead." )
+    """
diff --git a/cuda/cuda/ccuda.pyx b/cuda/cuda/ccuda.pyx
new file mode 100644
index 00000000..73f3fc5c
--- /dev/null
+++ b/cuda/cuda/ccuda.pyx
@@ -0,0 +1,7 @@
+from cuda.bindings.cydriver cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.ccuda module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cydriver module instead." )
+    """
diff --git a/cuda/cuda/ccudart.pxd b/cuda/cuda/ccudart.pxd
new file mode 100644
index 00000000..b32eece8
--- /dev/null
+++ b/cuda/cuda/ccudart.pxd
@@ -0,0 +1,7 @@
+from cuda.bindings.cyruntime cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.ccudart module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cyruntime module instead." )
+    """
diff --git a/cuda/cuda/ccudart.pyx b/cuda/cuda/ccudart.pyx
new file mode 100644
index 00000000..b32eece8
--- /dev/null
+++ b/cuda/cuda/ccudart.pyx
@@ -0,0 +1,7 @@
+from cuda.bindings.cyruntime cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.ccudart module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cyruntime module instead." )
+    """
diff --git a/cuda/cuda/cnvrtc.pxd b/cuda/cuda/cnvrtc.pxd
new file mode 100644
index 00000000..d4034084
--- /dev/null
+++ b/cuda/cuda/cnvrtc.pxd
@@ -0,0 +1,7 @@
+from cuda.bindings.cynvrtc cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.cnvrtc module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cynvrtc module instead." )
+    """
diff --git a/cuda/cuda/cnvrtc.pyx b/cuda/cuda/cnvrtc.pyx
new file mode 100644
index 00000000..d4034084
--- /dev/null
+++ b/cuda/cuda/cnvrtc.pyx
@@ -0,0 +1,7 @@
+from cuda.bindings.cynvrtc cimport *
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.cnvrtc module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.cynvrtc module instead." )
+    """
diff --git a/cuda/cuda/cuda.pyx b/cuda/cuda/cuda.pyx
new file mode 100644
index 00000000..f8b197f7
--- /dev/null
+++ b/cuda/cuda/cuda.pyx
@@ -0,0 +1,14 @@
+import warnings as _warnings
+
+from cuda.bindings.driver import *
+
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.cuda module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.driver module instead." )
+    """
+
+
+_warnings.warn("The cuda.cuda module is deprecated and will be removed in a future release, "
+               "please switch to use the cuda.bindings.driver module instead.", DeprecationWarning, stacklevel=2)
diff --git a/cuda/cuda/cudart.pyx b/cuda/cuda/cudart.pyx
new file mode 100644
index 00000000..8c342df8
--- /dev/null
+++ b/cuda/cuda/cudart.pyx
@@ -0,0 +1,14 @@
+import warnings as _warnings
+
+from cuda.bindings.runtime import *
+
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.cudart module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.runtime module instead." )
+    """
+
+
+_warnings.warn("The cuda.cudart module is deprecated and will be removed in a future release, "
+               "please switch to use the cuda.bindings.runtime module instead.", DeprecationWarning, stacklevel=2)
diff --git a/cuda/cuda/nvrtc.pyx b/cuda/cuda/nvrtc.pyx
new file mode 100644
index 00000000..4a9e048f
--- /dev/null
+++ b/cuda/cuda/nvrtc.pyx
@@ -0,0 +1,14 @@
+import warnings as _warnings
+
+from cuda.bindings.nvrtc import *
+
+
+cdef extern from *:
+    """
+    #pragma message ( "The cuda.nvrtc module is deprecated and will be removed in a future release, " \
+                      "please switch to use the cuda.bindings.nvrtc module instead." )
+    """
+
+
+_warnings.warn("The cuda.nvrtc module is deprecated and will be removed in a future release, "
+               "please switch to use the cuda.bindings.nvrtc module instead.", DeprecationWarning, stacklevel=2)
diff --git a/pyproject.toml b/cuda/pyproject.toml
similarity index 84%
rename from pyproject.toml
rename to cuda/pyproject.toml
index 6244def3..f4c9c5bc 100644
--- a/pyproject.toml
+++ b/cuda/pyproject.toml
@@ -1,4 +1,4 @@
-# Copyright 2023 NVIDIA Corporation.  All rights reserved.
+# Copyright 2023-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -24,9 +24,13 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Environment :: GPU :: NVIDIA CUDA",
 ]
 dynamic = ["version"]
+dependencies = [
+  "pywin32; sys_platform == 'win32'",
+]
 
 [project.urls]
 Repository = "https://github.com/NVIDIA/cuda-python"
@@ -48,7 +52,7 @@ Documentation = "https://nvidia.github.io/cuda-python/"
 [tool.versioneer]
 VCS = "git"
 style = "pep440"
-versionfile_source = "cuda/_version.py"
-versionfile_build = "cuda/_version.py"
+versionfile_source = "cuda/bindings/_version.py"
+versionfile_build = "cuda/bindings/_version.py"
 tag_prefix = "v"
 parentdir_prefix = "cuda-python-"
diff --git a/pytest.ini b/cuda/pytest.ini
similarity index 100%
rename from pytest.ini
rename to cuda/pytest.ini
diff --git a/requirements.txt b/cuda/requirements.txt
similarity index 78%
rename from requirements.txt
rename to cuda/requirements.txt
index 60bbdfcc..0cf074d5 100644
--- a/requirements.txt
+++ b/cuda/requirements.txt
@@ -6,3 +6,5 @@ pyclibrary>=0.1.7
 setuptools
 tomli; python_version < "3.11"
 versioneer==0.29
+wheel
+pywin32; sys_platform == 'win32'
diff --git a/setup.py b/cuda/setup.py
similarity index 68%
rename from setup.py
rename to cuda/setup.py
index 62f6c952..ec523626 100644
--- a/setup.py
+++ b/cuda/setup.py
@@ -1,4 +1,4 @@
-# Copyright 2021-2023 NVIDIA Corporation.  All rights reserved.
+# Copyright 2021-2024 NVIDIA Corporation.  All rights reserved.
 #
 # Please refer to the NVIDIA end user license agreement (EULA) associated
 # with this source code for terms and conditions that govern your use of
@@ -6,19 +6,21 @@
 # this software and related documentation outside the terms of the EULA
 # is strictly prohibited.
 
-from Cython import Tempita
-from Cython.Build import cythonize
-from distutils.sysconfig import get_python_lib
+import glob
 import os
 import platform
-from pyclibrary import CParser
 import sys
 import sysconfig
+
+from Cython import Tempita
+from Cython.Build import cythonize
+from pyclibrary import CParser
 from setuptools import find_packages, setup
 from setuptools.extension import Extension
 from setuptools.command.build_ext import build_ext
 import versioneer
 
+
 # ----------------------------------------------------------------------
 # Fetch configuration options
 
@@ -28,6 +30,7 @@
 if not CUDA_HOME:
     raise RuntimeError('Environment variable CUDA_HOME or CUDA_PATH is not set')
 
+CUDA_HOME = CUDA_HOME.split(os.pathsep)
 nthreads = int(os.environ.get("PARALLEL_LEVEL", "0") or "0")
 PARSER_CACHING = os.environ.get("CUDA_PYTHON_PARSER_CACHING", False)
 PARSER_CACHING = True if PARSER_CACHING else False
@@ -66,7 +69,7 @@
            'typedef enum libraryPropertyType_t libraryPropertyType_t;' : '',
            '  enum ' : '   ',
            ', enum ' : ', ',
-           '\(enum ' : '(',}
+           '\\(enum ' : '(',}
 
 found_types = []
 found_structs = {}
@@ -74,16 +77,18 @@
 found_functions = []
 found_values = []
 
-include_path = os.path.join(CUDA_HOME, 'include')
-print(f'Parsing headers in "{include_path}" (Caching {PARSER_CACHING})')
+include_path_list = [os.path.join(path, 'include') for path in CUDA_HOME]
+print(f'Parsing headers in "{include_path_list}" (Caching {PARSER_CACHING})')
 for library, header_list in header_dict.items():
     header_paths = []
     for header in header_list:
-        path = os.path.join(include_path, header)
+        path_candidate = [os.path.join(path, header) for path in include_path_list]
+        for path in path_candidate:
+            if os.path.exists(path):
+                header_paths += [path]
+                break
         if not os.path.exists(path):
             print(f'Missing header {header}')
-            continue
-        header_paths += [path]
 
     print(f'Parsing {library} headers')
     parser = CParser(header_paths,
@@ -100,21 +105,6 @@
     found_functions += {key for key in parser.defs['functions']}
     found_values += {key for key in parser.defs['values']}
 
-    # WAR: Temporary patch for select anon_ types
-    if 'CUlaunchAttributeValue_union' in parser.defs['unions']:
-        for name, typeName, _ in parser.defs['unions']['CUlaunchAttributeValue_union']['members']:
-            if name == 'clusterDim':
-                found_types += {'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_clusterDim_s'}
-            elif name == 'programmaticEvent':
-                found_types += {'struct _CUlaunchAttributeValue_CUlaunchAttributeValue_CUlaunchAttributeValue_union_programmaticEvent_s'}
-    if 'cudaLaunchAttributeValue' in parser.defs['unions']:
-        for name, typeName, _ in parser.defs['unions']['cudaLaunchAttributeValue']['members']:
-            if name == 'clusterDim':
-                found_types += {'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_clusterDim_s'}
-            elif name == 'programmaticEvent':
-                found_types += {'struct _cudaLaunchAttributeValue_cudaLaunchAttributeValue_cudaLaunchAttributeValue_programmaticEvent_s'}
-
-
 if len(found_functions) == 0:
     raise RuntimeError(f'Parser found no functions. Is CUDA_HOME setup correctly? (CUDA_HOME="{CUDA_HOME}")')
 
@@ -129,6 +119,7 @@ def unwrapMembers(found_dict):
 
 # ----------------------------------------------------------------------
 # Generate
+
 def fetch_input_files(path):
     return [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.in')]
 
@@ -138,9 +129,9 @@ def generate_output(infile, local):
 
     with open(infile) as f:
         pxdcontent = Tempita.Template(f.read()).substitute(local)
-    
+
     if os.path.exists(outfile):
-        with open(outfile) as f: 
+        with open(outfile) as f:
             if f.read() == pxdcontent:
                 print(f'Skipping {infile} (No change)')
                 return
@@ -149,9 +140,10 @@ def generate_output(infile, local):
         f.write(pxdcontent)
 
 path_list = [os.path.join('cuda'),
-             os.path.join('cuda', '_cuda'),
-             os.path.join('cuda', '_lib'),
-             os.path.join('cuda', '_lib', 'ccudart')]
+             os.path.join('cuda', 'bindings'),
+             os.path.join('cuda', 'bindings', '_bindings'),
+             os.path.join('cuda', 'bindings', '_lib'),
+             os.path.join('cuda', 'bindings', '_lib', 'cyruntime')]
 input_files = []
 for path in path_list:
     input_files += fetch_input_files(path)
@@ -165,9 +157,8 @@ def generate_output(infile, local):
 # For Cython
 include_dirs = [
     os.path.dirname(sysconfig.get_path("include")),
-    f'{CUDA_HOME}/include',
-]
-library_dirs = [get_python_lib(), os.path.join(os.sys.prefix, "lib")]
+] + include_path_list
+library_dirs = [sysconfig.get_path("platlib"), os.path.join(os.sys.prefix, "lib")]
 
 extra_compile_args = []
 extra_cythonize_kwargs = {}
@@ -186,49 +177,59 @@ def generate_output(infile, local):
         extra_compile_args += ['-O3']
 
 # For Setup
-if sys.platform == 'win32':
-    from distutils import _msvccompiler
-    _msvccompiler.PLAT_TO_VCVARS['win-amd64'] = 'amd64'
-
 extensions = []
 cmdclass = {}
 
 # ----------------------------------------------------------------------
 # Cythonize
 
-def do_cythonize(sources):
+def prep_extensions(sources):
+    pattern = sources[0]
+    files = glob.glob(pattern)
+    exts = []
+    for pyx in files:
+        mod_name = pyx.replace(".pyx", "").replace(os.sep, ".").replace("/", ".")
+        exts.append(
+            Extension(
+                mod_name,
+                sources=[pyx, *sources[1:]],
+                include_dirs=include_dirs,
+                library_dirs=library_dirs,
+                runtime_library_dirs=[],
+                libraries=[],
+                language="c++",
+                extra_compile_args=extra_compile_args,
+            )
+        )
+    return exts
+
+
+def do_cythonize(extensions):
     return cythonize(
-                    [
-                        Extension(
-                            "*",
-                            sources=sources,
-                            include_dirs=include_dirs,
-                            library_dirs=library_dirs,
-                            runtime_library_dirs=[],
-                            libraries=[],
-                            language="c++",
-                            extra_compile_args=extra_compile_args,
-                        )
-                    ],
-                    nthreads=nthreads,
-                    compiler_directives=dict(
-                        profile=True, language_level=3, embedsignature=True, binding=True
-                    ),
-                    **extra_cythonize_kwargs)
+        extensions,
+        nthreads=nthreads,
+        compiler_directives=dict(
+            profile=True, language_level=3, embedsignature=True, binding=True
+        ),
+        **extra_cythonize_kwargs)
+
 
 sources_list = [
     # private
-    ["cuda/_cuda/*.pyx", "cuda/_cuda/loader.cpp"],
+    ["cuda/bindings/_bindings/*.pyx", "cuda/bindings/_bindings/loader.cpp"],
     # utils
-    ["cuda/_lib/*.pyx", "cuda/_lib/param_packer.cpp"],
-    ["cuda/_lib/ccudart/*.pyx"],
+    ["cuda/bindings/_lib/*.pyx", "cuda/bindings/_lib/param_packer.cpp"],
+    ["cuda/bindings/_lib/cyruntime/*.pyx"],
     # public
+    ["cuda/bindings/*.pyx"],
+    # public (deprecated, to be removed)
     ["cuda/*.pyx"],
     # tests
-    ["cuda/tests/*.pyx"]]
+    ["cuda/bindings/tests/*.pyx"],
+]
 
 for sources in sources_list:
-    extensions += do_cythonize(sources)
+    extensions += prep_extensions(sources)
 
 # ---------------------------------------------------------------------
 # Custom build_ext command
@@ -254,11 +255,11 @@ def finalize_options(self):
 
 setup(
     version=versioneer.get_version(),
-    ext_modules=extensions,
-    packages=find_packages(include=["cuda", "cuda.*"]),
+    ext_modules=do_cythonize(extensions),
+    packages=find_packages(include=["cuda.cuda", "cuda.cuda.*", "cuda.cuda.bindings", "cuda.cuda.bindings._bindings", "cuda.cuda.bindings._lib", "cuda.cuda.bindings._lib.cyruntime", "cuda.cuda.bindings.tests"]),
     package_data=dict.fromkeys(
-        find_packages(include=["cuda", "cuda.*"]),
-        ["*.pxd", "*.pyx", "*.h", "*.cpp"],
+        find_packages(include=["cuda.cuda", "cuda.cuda.*", "cuda.cuda.bindings", "cuda.cuda.bindings._bindings", "cuda.cuda.bindings._lib", "cuda.cuda.bindings._lib.cyruntime", "cuda.cuda.bindings.tests"]),
+        ["*.pxd", "*.pyx", "*.py", "*.h", "*.cpp"],
     ),
     cmdclass=cmdclass,
     zip_safe=False,
diff --git a/docs/_sources/release/11.8.1-notes.md.txt b/docs/_sources/release/11.8.1-notes.md.txt
index cb1aebf8..3d8d9da5 100644
--- a/docs/_sources/release/11.8.1-notes.md.txt
+++ b/docs/_sources/release/11.8.1-notes.md.txt
@@ -1,6 +1,6 @@
 # CUDA Python 11.8.1 Release notes
 
-Released on November 4, 2022
+Released on October ??, 2022
 
 ## Hightlights
 - Resolves [issue #27](https://github.com/NVIDIA/cuda-python/issues/24)
diff --git a/docs/release/11.8.1-notes.html b/docs/release/11.8.1-notes.html
index 32babd5a..a6cdfcc8 100644
--- a/docs/release/11.8.1-notes.html
+++ b/docs/release/11.8.1-notes.html
@@ -218,7 +218,7 @@
         <article role="main">
           <div class="section" id="cuda-python-11-8-1-release-notes">
 <h1>CUDA Python 11.8.1 Release notes<a class="headerlink" href="#cuda-python-11-8-1-release-notes" title="Permalink to this headline">#</a></h1>
-<p>Released on November 4, 2022</p>
+<p>Released on October ??, 2022</p>
 <div class="section" id="hightlights">
 <h2>Hightlights<a class="headerlink" href="#hightlights" title="Permalink to this headline">#</a></h2>
 <ul class="simple">
diff --git a/docs/searchindex.js b/docs/searchindex.js
index 541f8ca4..e95c5640 100644
--- a/docs/searchindex.js
+++ b/docs/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["api","conduct","contribute","index","install","module/cuda","module/cudart","module/nvrtc","motivation","overview","release","release/11.4.0-notes","release/11.5.0-notes","release/11.6.0-notes","release/11.6.1-notes","release/11.7.0-notes","release/11.7.1-notes","release/11.8.0-notes","release/11.8.1-notes"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":5,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,sphinx:56},filenames:["api.rst","conduct.md","contribute.md","index.rst","install.md","module/cuda.rst","module/cudart.rst","module/nvrtc.rst","motivation.md","overview.md","release.md","release/11.4.0-notes.md","release/11.5.0-notes.md","release/11.6.0-notes.md","release/11.6.1-notes.md","release/11.7.0-notes.md","release/11.7.1-notes.md","release/11.8.0-notes.md","release/11.8.1-notes.md"],objects:{"cuda.cuda":[[5,0,1,"","CUDA_ARRAY3D_2DARRAY"],[5,0,1,"","CUDA_ARRAY3D_COLOR_ATTACHMENT"],[5,0,1,"","CUDA_ARRAY3D_CUBEMAP"],[5,0,1,"","CUDA_ARRAY3D_DEFERRED_MAPPING"],[5,0,1,"","CUDA_ARRAY3D_DEPTH_TEXTURE"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR_st"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR_v2"],[5,0,1,"","CUDA_ARRAY3D_LAYERED"],[5,0,1,"","CUDA_ARRAY3D_SPARSE"],[5,0,1,"","CUDA_ARRAY3D_SURFACE_LDST"],[5,0,1,"","CUDA_ARRAY3D_TEXTURE_GATHER"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR_st"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR_v2"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS_st"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS_v1"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES_st"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES_v1"],[5,1,1,"","CUDA_BATCH_MEM_OP_NODE_PARAMS"],[5,1,1,"","CUDA_BATCH_MEM_OP_NODE_PARAMS_st"],[5,0,1,"","CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC"],[5,0,1,"","CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC"],[5,0,1,"","CUDA_EGL_INFINITE_TIMEOUT"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1"],[5,0,1,"","CUDA_EXTERNAL_MEMORY_DEDICATED"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1"],[5,0,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1"],[5,0,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS_st"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1"],[5,1,1,"","CUDA_HOST_NODE_PARAMS"],[5,1,1,"","CUDA_HOST_NODE_PARAMS_st"],[5,1,1,"","CUDA_HOST_NODE_PARAMS_v1"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS_st"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS_v1"],[5,1,1,"","CUDA_LAUNCH_PARAMS"],[5,1,1,"","CUDA_LAUNCH_PARAMS_st"],[5,1,1,"","CUDA_LAUNCH_PARAMS_v1"],[5,1,1,"","CUDA_MEMCPY2D"],[5,1,1,"","CUDA_MEMCPY2D_st"],[5,1,1,"","CUDA_MEMCPY2D_v2"],[5,1,1,"","CUDA_MEMCPY3D"],[5,1,1,"","CUDA_MEMCPY3D_PEER"],[5,1,1,"","CUDA_MEMCPY3D_PEER_st"],[5,1,1,"","CUDA_MEMCPY3D_PEER_v1"],[5,1,1,"","CUDA_MEMCPY3D_st"],[5,1,1,"","CUDA_MEMCPY3D_v2"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS_st"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS_v1"],[5,1,1,"","CUDA_MEM_ALLOC_NODE_PARAMS"],[5,1,1,"","CUDA_MEM_ALLOC_NODE_PARAMS_st"],[5,0,1,"","CUDA_NVSCISYNC_ATTR_SIGNAL"],[5,0,1,"","CUDA_NVSCISYNC_ATTR_WAIT"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1"],[5,1,1,"","CUDA_RESOURCE_DESC"],[5,1,1,"","CUDA_RESOURCE_DESC_st"],[5,1,1,"","CUDA_RESOURCE_DESC_v1"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC_st"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC_v1"],[5,1,1,"","CUDA_TEXTURE_DESC"],[5,1,1,"","CUDA_TEXTURE_DESC_st"],[5,1,1,"","CUDA_TEXTURE_DESC_v1"],[5,0,1,"","CUDA_VERSION"],[5,1,1,"","CUGLDeviceList"],[5,1,1,"","CUGPUDirectRDMAWritesOrdering"],[5,0,1,"","CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL"],[5,0,1,"","CU_DEVICE_CPU"],[5,0,1,"","CU_DEVICE_INVALID"],[5,0,1,"","CU_IPC_HANDLE_SIZE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_PRIORITY"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_POINTER"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_SIZE"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT"],[5,0,1,"","CU_LAUNCH_PARAM_END"],[5,0,1,"","CU_LAUNCH_PARAM_END_AS_INT"],[5,0,1,"","CU_MEMHOSTALLOC_DEVICEMAP"],[5,0,1,"","CU_MEMHOSTALLOC_PORTABLE"],[5,0,1,"","CU_MEMHOSTALLOC_WRITECOMBINED"],[5,0,1,"","CU_MEMHOSTREGISTER_DEVICEMAP"],[5,0,1,"","CU_MEMHOSTREGISTER_IOMEMORY"],[5,0,1,"","CU_MEMHOSTREGISTER_PORTABLE"],[5,0,1,"","CU_MEMHOSTREGISTER_READ_ONLY"],[5,0,1,"","CU_MEM_CREATE_USAGE_TILE_POOL"],[5,0,1,"","CU_PARAM_TR_DEFAULT"],[5,0,1,"","CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY"],[5,0,1,"","CU_STREAM_LEGACY"],[5,0,1,"","CU_STREAM_PER_THREAD"],[5,0,1,"","CU_TRSA_OVERRIDE_FORMAT"],[5,0,1,"","CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION"],[5,0,1,"","CU_TRSF_NORMALIZED_COORDINATES"],[5,0,1,"","CU_TRSF_READ_AS_INTEGER"],[5,0,1,"","CU_TRSF_SEAMLESS_CUBEMAP"],[5,0,1,"","CU_TRSF_SRGB"],[5,1,1,"","CUaccessPolicyWindow"],[5,1,1,"","CUaccessPolicyWindow_st"],[5,1,1,"","CUaccessPolicyWindow_v1"],[5,1,1,"","CUaccessProperty"],[5,1,1,"","CUaddress_mode"],[5,1,1,"","CUarray"],[5,1,1,"","CUarrayMapInfo"],[5,1,1,"","CUarrayMapInfo_st"],[5,1,1,"","CUarrayMapInfo_v1"],[5,1,1,"","CUarraySparseSubresourceType"],[5,1,1,"","CUarray_cubemap_face"],[5,1,1,"","CUarray_format"],[5,1,1,"","CUclusterSchedulingPolicy"],[5,1,1,"","CUcomputemode"],[5,1,1,"","CUcontext"],[5,1,1,"","CUctx_flags"],[5,1,1,"","CUdevice"],[5,1,1,"","CUdevice_P2PAttribute"],[5,1,1,"","CUdevice_attribute"],[5,1,1,"","CUdevice_v1"],[5,1,1,"","CUdeviceptr"],[5,1,1,"","CUdeviceptr_v2"],[5,1,1,"","CUdevprop"],[5,1,1,"","CUdevprop_st"],[5,1,1,"","CUdevprop_v1"],[5,1,1,"","CUdriverProcAddress_flags"],[5,1,1,"","CUeglColorFormat"],[5,1,1,"","CUeglFrame"],[5,1,1,"","CUeglFrameType"],[5,1,1,"","CUeglFrame_st"],[5,1,1,"","CUeglFrame_v1"],[5,1,1,"","CUeglResourceLocationFlags"],[5,1,1,"","CUeglStreamConnection"],[5,1,1,"","CUevent"],[5,1,1,"","CUevent_flags"],[5,1,1,"","CUevent_record_flags"],[5,1,1,"","CUevent_sched_flags"],[5,1,1,"","CUevent_wait_flags"],[5,1,1,"","CUexecAffinityParam"],[5,1,1,"","CUexecAffinityParam_st"],[5,1,1,"","CUexecAffinityParam_v1"],[5,1,1,"","CUexecAffinitySmCount"],[5,1,1,"","CUexecAffinitySmCount_st"],[5,1,1,"","CUexecAffinitySmCount_v1"],[5,1,1,"","CUexecAffinityType"],[5,1,1,"","CUexternalMemory"],[5,1,1,"","CUexternalMemoryHandleType"],[5,1,1,"","CUexternalSemaphore"],[5,1,1,"","CUexternalSemaphoreHandleType"],[5,1,1,"","CUfilter_mode"],[5,1,1,"","CUflushGPUDirectRDMAWritesOptions"],[5,1,1,"","CUflushGPUDirectRDMAWritesScope"],[5,1,1,"","CUflushGPUDirectRDMAWritesTarget"],[5,1,1,"","CUfunc_cache"],[5,1,1,"","CUfunction"],[5,1,1,"","CUfunction_attribute"],[5,1,1,"","CUgraph"],[5,1,1,"","CUgraphDebugDot_flags"],[5,1,1,"","CUgraphExec"],[5,1,1,"","CUgraphExecUpdateResult"],[5,1,1,"","CUgraphInstantiate_flags"],[5,1,1,"","CUgraphMem_attribute"],[5,1,1,"","CUgraphNode"],[5,1,1,"","CUgraphNodeType"],[5,1,1,"","CUgraphicsMapResourceFlags"],[5,1,1,"","CUgraphicsRegisterFlags"],[5,1,1,"","CUgraphicsResource"],[5,1,1,"","CUhostFn"],[5,1,1,"","CUipcEventHandle"],[5,1,1,"","CUipcEventHandle_st"],[5,1,1,"","CUipcEventHandle_v1"],[5,1,1,"","CUipcMemHandle"],[5,1,1,"","CUipcMemHandle_st"],[5,1,1,"","CUipcMemHandle_v1"],[5,1,1,"","CUipcMem_flags"],[5,1,1,"","CUjitInputType"],[5,1,1,"","CUjit_cacheMode"],[5,1,1,"","CUjit_fallback"],[5,1,1,"","CUjit_option"],[5,1,1,"","CUjit_target"],[5,1,1,"","CUkernelNodeAttrValue"],[5,1,1,"","CUkernelNodeAttrValue_v1"],[5,1,1,"","CUlaunchAttribute"],[5,1,1,"","CUlaunchAttributeValue"],[5,1,1,"","CUlaunchAttributeValue_union"],[5,1,1,"","CUlaunchAttribute_st"],[5,1,1,"","CUlaunchConfig"],[5,1,1,"","CUlaunchConfig_st"],[5,1,1,"","CUlimit"],[5,1,1,"","CUlinkState"],[5,1,1,"","CUmemAccessDesc"],[5,1,1,"","CUmemAccessDesc_st"],[5,1,1,"","CUmemAccessDesc_v1"],[5,1,1,"","CUmemAccess_flags"],[5,1,1,"","CUmemAllocationCompType"],[5,1,1,"","CUmemAllocationGranularity_flags"],[5,1,1,"","CUmemAllocationHandleType"],[5,1,1,"","CUmemAllocationProp"],[5,1,1,"","CUmemAllocationProp_st"],[5,1,1,"","CUmemAllocationProp_v1"],[5,1,1,"","CUmemAllocationType"],[5,1,1,"","CUmemAttach_flags"],[5,1,1,"","CUmemGenericAllocationHandle"],[5,1,1,"","CUmemGenericAllocationHandle_v1"],[5,1,1,"","CUmemHandleType"],[5,1,1,"","CUmemLocation"],[5,1,1,"","CUmemLocationType"],[5,1,1,"","CUmemLocation_st"],[5,1,1,"","CUmemLocation_v1"],[5,1,1,"","CUmemOperationType"],[5,1,1,"","CUmemPoolProps"],[5,1,1,"","CUmemPoolProps_st"],[5,1,1,"","CUmemPoolProps_v1"],[5,1,1,"","CUmemPoolPtrExportData"],[5,1,1,"","CUmemPoolPtrExportData_st"],[5,1,1,"","CUmemPoolPtrExportData_v1"],[5,1,1,"","CUmemPool_attribute"],[5,1,1,"","CUmemRangeHandleType"],[5,1,1,"","CUmem_advise"],[5,1,1,"","CUmem_range_attribute"],[5,1,1,"","CUmemoryPool"],[5,1,1,"","CUmemorytype"],[5,1,1,"","CUmipmappedArray"],[5,1,1,"","CUmodule"],[5,1,1,"","CUmoduleLoadingMode"],[5,1,1,"","CUoccupancyB2DSize"],[5,1,1,"","CUoccupancy_flags"],[5,1,1,"","CUpointer_attribute"],[5,1,1,"","CUresourceViewFormat"],[5,1,1,"","CUresourcetype"],[5,1,1,"","CUresult"],[5,1,1,"","CUshared_carveout"],[5,1,1,"","CUsharedconfig"],[5,1,1,"","CUstream"],[5,1,1,"","CUstreamAttrID"],[5,1,1,"","CUstreamAttrValue"],[5,1,1,"","CUstreamAttrValue_v1"],[5,1,1,"","CUstreamBatchMemOpParams"],[5,1,1,"","CUstreamBatchMemOpParams_union"],[5,1,1,"","CUstreamBatchMemOpParams_v1"],[5,1,1,"","CUstreamBatchMemOpType"],[5,1,1,"","CUstreamCallback"],[5,1,1,"","CUstreamCaptureMode"],[5,1,1,"","CUstreamCaptureStatus"],[5,1,1,"","CUstreamMemoryBarrier_flags"],[5,1,1,"","CUstreamUpdateCaptureDependencies_flags"],[5,1,1,"","CUstreamWaitValue_flags"],[5,1,1,"","CUstreamWriteValue_flags"],[5,1,1,"","CUstream_flags"],[5,1,1,"","CUsurfObject"],[5,1,1,"","CUsurfObject_v1"],[5,1,1,"","CUsurfref"],[5,1,1,"","CUsynchronizationPolicy"],[5,1,1,"","CUtexObject"],[5,1,1,"","CUtexObject_v1"],[5,1,1,"","CUtexref"],[5,1,1,"","CUuserObject"],[5,1,1,"","CUuserObjectRetain_flags"],[5,1,1,"","CUuserObject_flags"],[5,1,1,"","CUuuid"],[5,1,1,"","CUuuid_st"],[5,0,1,"","MAX_PLANES"],[5,1,1,"","cl_context_flags"],[5,1,1,"","cl_event_flags"],[5,3,1,"","cuArray3DCreate"],[5,3,1,"","cuArray3DGetDescriptor"],[5,3,1,"","cuArrayCreate"],[5,3,1,"","cuArrayDestroy"],[5,3,1,"","cuArrayGetDescriptor"],[5,3,1,"","cuArrayGetMemoryRequirements"],[5,3,1,"","cuArrayGetPlane"],[5,3,1,"","cuArrayGetSparseProperties"],[5,3,1,"","cuCtxCreate"],[5,3,1,"","cuCtxCreate_v3"],[5,3,1,"","cuCtxDestroy"],[5,3,1,"","cuCtxDisablePeerAccess"],[5,3,1,"","cuCtxEnablePeerAccess"],[5,3,1,"","cuCtxGetApiVersion"],[5,3,1,"","cuCtxGetCacheConfig"],[5,3,1,"","cuCtxGetCurrent"],[5,3,1,"","cuCtxGetDevice"],[5,3,1,"","cuCtxGetExecAffinity"],[5,3,1,"","cuCtxGetFlags"],[5,3,1,"","cuCtxGetLimit"],[5,3,1,"","cuCtxGetSharedMemConfig"],[5,3,1,"","cuCtxGetStreamPriorityRange"],[5,3,1,"","cuCtxPopCurrent"],[5,3,1,"","cuCtxPushCurrent"],[5,3,1,"","cuCtxResetPersistingL2Cache"],[5,3,1,"","cuCtxSetCacheConfig"],[5,3,1,"","cuCtxSetCurrent"],[5,3,1,"","cuCtxSetLimit"],[5,3,1,"","cuCtxSetSharedMemConfig"],[5,3,1,"","cuCtxSynchronize"],[5,3,1,"","cuDestroyExternalMemory"],[5,3,1,"","cuDestroyExternalSemaphore"],[5,3,1,"","cuDeviceCanAccessPeer"],[5,3,1,"","cuDeviceGet"],[5,3,1,"","cuDeviceGetAttribute"],[5,3,1,"","cuDeviceGetByPCIBusId"],[5,3,1,"","cuDeviceGetCount"],[5,3,1,"","cuDeviceGetDefaultMemPool"],[5,3,1,"","cuDeviceGetGraphMemAttribute"],[5,3,1,"","cuDeviceGetLuid"],[5,3,1,"","cuDeviceGetMemPool"],[5,3,1,"","cuDeviceGetName"],[5,3,1,"","cuDeviceGetNvSciSyncAttributes"],[5,3,1,"","cuDeviceGetP2PAttribute"],[5,3,1,"","cuDeviceGetPCIBusId"],[5,3,1,"","cuDeviceGetTexture1DLinearMaxWidth"],[5,3,1,"","cuDeviceGetUuid"],[5,3,1,"","cuDeviceGetUuid_v2"],[5,3,1,"","cuDeviceGraphMemTrim"],[5,3,1,"","cuDevicePrimaryCtxGetState"],[5,3,1,"","cuDevicePrimaryCtxRelease"],[5,3,1,"","cuDevicePrimaryCtxReset"],[5,3,1,"","cuDevicePrimaryCtxRetain"],[5,3,1,"","cuDevicePrimaryCtxSetFlags"],[5,3,1,"","cuDeviceSetGraphMemAttribute"],[5,3,1,"","cuDeviceSetMemPool"],[5,3,1,"","cuDeviceTotalMem"],[5,3,1,"","cuDriverGetVersion"],[5,3,1,"","cuEGLStreamConsumerAcquireFrame"],[5,3,1,"","cuEGLStreamConsumerConnect"],[5,3,1,"","cuEGLStreamConsumerConnectWithFlags"],[5,3,1,"","cuEGLStreamConsumerDisconnect"],[5,3,1,"","cuEGLStreamConsumerReleaseFrame"],[5,3,1,"","cuEGLStreamProducerConnect"],[5,3,1,"","cuEGLStreamProducerDisconnect"],[5,3,1,"","cuEGLStreamProducerPresentFrame"],[5,3,1,"","cuEGLStreamProducerReturnFrame"],[5,3,1,"","cuEventCreate"],[5,3,1,"","cuEventCreateFromEGLSync"],[5,3,1,"","cuEventDestroy"],[5,3,1,"","cuEventElapsedTime"],[5,3,1,"","cuEventQuery"],[5,3,1,"","cuEventRecord"],[5,3,1,"","cuEventRecordWithFlags"],[5,3,1,"","cuEventSynchronize"],[5,3,1,"","cuExternalMemoryGetMappedBuffer"],[5,3,1,"","cuExternalMemoryGetMappedMipmappedArray"],[5,3,1,"","cuFlushGPUDirectRDMAWrites"],[5,3,1,"","cuFuncGetAttribute"],[5,3,1,"","cuFuncGetModule"],[5,3,1,"","cuFuncSetAttribute"],[5,3,1,"","cuFuncSetCacheConfig"],[5,3,1,"","cuFuncSetSharedMemConfig"],[5,3,1,"","cuGLGetDevices"],[5,3,1,"","cuGetErrorName"],[5,3,1,"","cuGetErrorString"],[5,3,1,"","cuGetProcAddress"],[5,3,1,"","cuGraphAddBatchMemOpNode"],[5,3,1,"","cuGraphAddChildGraphNode"],[5,3,1,"","cuGraphAddDependencies"],[5,3,1,"","cuGraphAddEmptyNode"],[5,3,1,"","cuGraphAddEventRecordNode"],[5,3,1,"","cuGraphAddEventWaitNode"],[5,3,1,"","cuGraphAddExternalSemaphoresSignalNode"],[5,3,1,"","cuGraphAddExternalSemaphoresWaitNode"],[5,3,1,"","cuGraphAddHostNode"],[5,3,1,"","cuGraphAddKernelNode"],[5,3,1,"","cuGraphAddMemAllocNode"],[5,3,1,"","cuGraphAddMemFreeNode"],[5,3,1,"","cuGraphAddMemcpyNode"],[5,3,1,"","cuGraphAddMemsetNode"],[5,3,1,"","cuGraphBatchMemOpNodeGetParams"],[5,3,1,"","cuGraphBatchMemOpNodeSetParams"],[5,3,1,"","cuGraphChildGraphNodeGetGraph"],[5,3,1,"","cuGraphClone"],[5,3,1,"","cuGraphCreate"],[5,3,1,"","cuGraphDebugDotPrint"],[5,3,1,"","cuGraphDestroy"],[5,3,1,"","cuGraphDestroyNode"],[5,3,1,"","cuGraphEventRecordNodeGetEvent"],[5,3,1,"","cuGraphEventRecordNodeSetEvent"],[5,3,1,"","cuGraphEventWaitNodeGetEvent"],[5,3,1,"","cuGraphEventWaitNodeSetEvent"],[5,3,1,"","cuGraphExecBatchMemOpNodeSetParams"],[5,3,1,"","cuGraphExecChildGraphNodeSetParams"],[5,3,1,"","cuGraphExecDestroy"],[5,3,1,"","cuGraphExecEventRecordNodeSetEvent"],[5,3,1,"","cuGraphExecEventWaitNodeSetEvent"],[5,3,1,"","cuGraphExecExternalSemaphoresSignalNodeSetParams"],[5,3,1,"","cuGraphExecExternalSemaphoresWaitNodeSetParams"],[5,3,1,"","cuGraphExecHostNodeSetParams"],[5,3,1,"","cuGraphExecKernelNodeSetParams"],[5,3,1,"","cuGraphExecMemcpyNodeSetParams"],[5,3,1,"","cuGraphExecMemsetNodeSetParams"],[5,3,1,"","cuGraphExecUpdate"],[5,3,1,"","cuGraphExternalSemaphoresSignalNodeGetParams"],[5,3,1,"","cuGraphExternalSemaphoresSignalNodeSetParams"],[5,3,1,"","cuGraphExternalSemaphoresWaitNodeGetParams"],[5,3,1,"","cuGraphExternalSemaphoresWaitNodeSetParams"],[5,3,1,"","cuGraphGetEdges"],[5,3,1,"","cuGraphGetNodes"],[5,3,1,"","cuGraphGetRootNodes"],[5,3,1,"","cuGraphHostNodeGetParams"],[5,3,1,"","cuGraphHostNodeSetParams"],[5,3,1,"","cuGraphInstantiate"],[5,3,1,"","cuGraphInstantiateWithFlags"],[5,3,1,"","cuGraphKernelNodeCopyAttributes"],[5,3,1,"","cuGraphKernelNodeGetAttribute"],[5,3,1,"","cuGraphKernelNodeGetParams"],[5,3,1,"","cuGraphKernelNodeSetAttribute"],[5,3,1,"","cuGraphKernelNodeSetParams"],[5,3,1,"","cuGraphLaunch"],[5,3,1,"","cuGraphMemAllocNodeGetParams"],[5,3,1,"","cuGraphMemFreeNodeGetParams"],[5,3,1,"","cuGraphMemcpyNodeGetParams"],[5,3,1,"","cuGraphMemcpyNodeSetParams"],[5,3,1,"","cuGraphMemsetNodeGetParams"],[5,3,1,"","cuGraphMemsetNodeSetParams"],[5,3,1,"","cuGraphNodeFindInClone"],[5,3,1,"","cuGraphNodeGetDependencies"],[5,3,1,"","cuGraphNodeGetDependentNodes"],[5,3,1,"","cuGraphNodeGetEnabled"],[5,3,1,"","cuGraphNodeGetType"],[5,3,1,"","cuGraphNodeSetEnabled"],[5,3,1,"","cuGraphReleaseUserObject"],[5,3,1,"","cuGraphRemoveDependencies"],[5,3,1,"","cuGraphRetainUserObject"],[5,3,1,"","cuGraphUpload"],[5,3,1,"","cuGraphicsEGLRegisterImage"],[5,3,1,"","cuGraphicsGLRegisterBuffer"],[5,3,1,"","cuGraphicsGLRegisterImage"],[5,3,1,"","cuGraphicsMapResources"],[5,3,1,"","cuGraphicsResourceGetMappedEglFrame"],[5,3,1,"","cuGraphicsResourceGetMappedMipmappedArray"],[5,3,1,"","cuGraphicsResourceGetMappedPointer"],[5,3,1,"","cuGraphicsResourceSetMapFlags"],[5,3,1,"","cuGraphicsSubResourceGetMappedArray"],[5,3,1,"","cuGraphicsUnmapResources"],[5,3,1,"","cuGraphicsUnregisterResource"],[5,3,1,"","cuGraphicsVDPAURegisterOutputSurface"],[5,3,1,"","cuGraphicsVDPAURegisterVideoSurface"],[5,3,1,"","cuImportExternalMemory"],[5,3,1,"","cuImportExternalSemaphore"],[5,3,1,"","cuInit"],[5,3,1,"","cuIpcCloseMemHandle"],[5,3,1,"","cuIpcGetEventHandle"],[5,3,1,"","cuIpcGetMemHandle"],[5,3,1,"","cuIpcOpenEventHandle"],[5,3,1,"","cuIpcOpenMemHandle"],[5,3,1,"","cuLaunchCooperativeKernel"],[5,3,1,"","cuLaunchCooperativeKernelMultiDevice"],[5,3,1,"","cuLaunchHostFunc"],[5,3,1,"","cuLaunchKernel"],[5,3,1,"","cuLaunchKernelEx"],[5,3,1,"","cuLinkAddData"],[5,3,1,"","cuLinkAddFile"],[5,3,1,"","cuLinkComplete"],[5,3,1,"","cuLinkCreate"],[5,3,1,"","cuLinkDestroy"],[5,3,1,"","cuMemAddressFree"],[5,3,1,"","cuMemAddressReserve"],[5,3,1,"","cuMemAdvise"],[5,3,1,"","cuMemAlloc"],[5,3,1,"","cuMemAllocAsync"],[5,3,1,"","cuMemAllocFromPoolAsync"],[5,3,1,"","cuMemAllocHost"],[5,3,1,"","cuMemAllocManaged"],[5,3,1,"","cuMemAllocPitch"],[5,3,1,"","cuMemCreate"],[5,3,1,"","cuMemExportToShareableHandle"],[5,3,1,"","cuMemFree"],[5,3,1,"","cuMemFreeAsync"],[5,3,1,"","cuMemFreeHost"],[5,3,1,"","cuMemGetAccess"],[5,3,1,"","cuMemGetAddressRange"],[5,3,1,"","cuMemGetAllocationGranularity"],[5,3,1,"","cuMemGetAllocationPropertiesFromHandle"],[5,3,1,"","cuMemGetHandleForAddressRange"],[5,3,1,"","cuMemGetInfo"],[5,3,1,"","cuMemHostAlloc"],[5,3,1,"","cuMemHostGetDevicePointer"],[5,3,1,"","cuMemHostGetFlags"],[5,3,1,"","cuMemHostRegister"],[5,3,1,"","cuMemHostUnregister"],[5,3,1,"","cuMemImportFromShareableHandle"],[5,3,1,"","cuMemMap"],[5,3,1,"","cuMemMapArrayAsync"],[5,3,1,"","cuMemPoolCreate"],[5,3,1,"","cuMemPoolDestroy"],[5,3,1,"","cuMemPoolExportPointer"],[5,3,1,"","cuMemPoolExportToShareableHandle"],[5,3,1,"","cuMemPoolGetAccess"],[5,3,1,"","cuMemPoolGetAttribute"],[5,3,1,"","cuMemPoolImportFromShareableHandle"],[5,3,1,"","cuMemPoolImportPointer"],[5,3,1,"","cuMemPoolSetAccess"],[5,3,1,"","cuMemPoolSetAttribute"],[5,3,1,"","cuMemPoolTrimTo"],[5,3,1,"","cuMemPrefetchAsync"],[5,3,1,"","cuMemRangeGetAttribute"],[5,3,1,"","cuMemRangeGetAttributes"],[5,3,1,"","cuMemRelease"],[5,3,1,"","cuMemRetainAllocationHandle"],[5,3,1,"","cuMemSetAccess"],[5,3,1,"","cuMemUnmap"],[5,3,1,"","cuMemcpy"],[5,3,1,"","cuMemcpy2D"],[5,3,1,"","cuMemcpy2DAsync"],[5,3,1,"","cuMemcpy2DUnaligned"],[5,3,1,"","cuMemcpy3D"],[5,3,1,"","cuMemcpy3DAsync"],[5,3,1,"","cuMemcpy3DPeer"],[5,3,1,"","cuMemcpy3DPeerAsync"],[5,3,1,"","cuMemcpyAsync"],[5,3,1,"","cuMemcpyAtoA"],[5,3,1,"","cuMemcpyAtoD"],[5,3,1,"","cuMemcpyAtoH"],[5,3,1,"","cuMemcpyAtoHAsync"],[5,3,1,"","cuMemcpyDtoA"],[5,3,1,"","cuMemcpyDtoD"],[5,3,1,"","cuMemcpyDtoDAsync"],[5,3,1,"","cuMemcpyDtoH"],[5,3,1,"","cuMemcpyDtoHAsync"],[5,3,1,"","cuMemcpyHtoA"],[5,3,1,"","cuMemcpyHtoAAsync"],[5,3,1,"","cuMemcpyHtoD"],[5,3,1,"","cuMemcpyHtoDAsync"],[5,3,1,"","cuMemcpyPeer"],[5,3,1,"","cuMemcpyPeerAsync"],[5,3,1,"","cuMemsetD16"],[5,3,1,"","cuMemsetD16Async"],[5,3,1,"","cuMemsetD2D16"],[5,3,1,"","cuMemsetD2D16Async"],[5,3,1,"","cuMemsetD2D32"],[5,3,1,"","cuMemsetD2D32Async"],[5,3,1,"","cuMemsetD2D8"],[5,3,1,"","cuMemsetD2D8Async"],[5,3,1,"","cuMemsetD32"],[5,3,1,"","cuMemsetD32Async"],[5,3,1,"","cuMemsetD8"],[5,3,1,"","cuMemsetD8Async"],[5,3,1,"","cuMipmappedArrayCreate"],[5,3,1,"","cuMipmappedArrayDestroy"],[5,3,1,"","cuMipmappedArrayGetLevel"],[5,3,1,"","cuMipmappedArrayGetMemoryRequirements"],[5,3,1,"","cuMipmappedArrayGetSparseProperties"],[5,3,1,"","cuModuleGetFunction"],[5,3,1,"","cuModuleGetGlobal"],[5,3,1,"","cuModuleGetLoadingMode"],[5,3,1,"","cuModuleGetSurfRef"],[5,3,1,"","cuModuleGetTexRef"],[5,3,1,"","cuModuleLoad"],[5,3,1,"","cuModuleLoadData"],[5,3,1,"","cuModuleLoadDataEx"],[5,3,1,"","cuModuleLoadFatBinary"],[5,3,1,"","cuModuleUnload"],[5,3,1,"","cuOccupancyAvailableDynamicSMemPerBlock"],[5,3,1,"","cuOccupancyMaxActiveBlocksPerMultiprocessor"],[5,3,1,"","cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"],[5,3,1,"","cuOccupancyMaxActiveClusters"],[5,3,1,"","cuOccupancyMaxPotentialBlockSize"],[5,3,1,"","cuOccupancyMaxPotentialBlockSizeWithFlags"],[5,3,1,"","cuOccupancyMaxPotentialClusterSize"],[5,3,1,"","cuPointerGetAttribute"],[5,3,1,"","cuPointerGetAttributes"],[5,3,1,"","cuPointerSetAttribute"],[5,3,1,"","cuProfilerStart"],[5,3,1,"","cuProfilerStop"],[5,3,1,"","cuSignalExternalSemaphoresAsync"],[5,3,1,"","cuStreamAddCallback"],[5,3,1,"","cuStreamAttachMemAsync"],[5,3,1,"","cuStreamBatchMemOp"],[5,3,1,"","cuStreamBatchMemOp_v2"],[5,3,1,"","cuStreamBeginCapture"],[5,3,1,"","cuStreamCopyAttributes"],[5,3,1,"","cuStreamCreate"],[5,3,1,"","cuStreamCreateWithPriority"],[5,3,1,"","cuStreamDestroy"],[5,3,1,"","cuStreamEndCapture"],[5,3,1,"","cuStreamGetAttribute"],[5,3,1,"","cuStreamGetCaptureInfo"],[5,3,1,"","cuStreamGetCaptureInfo_v2"],[5,3,1,"","cuStreamGetCtx"],[5,3,1,"","cuStreamGetFlags"],[5,3,1,"","cuStreamGetPriority"],[5,3,1,"","cuStreamIsCapturing"],[5,3,1,"","cuStreamQuery"],[5,3,1,"","cuStreamSetAttribute"],[5,3,1,"","cuStreamSynchronize"],[5,3,1,"","cuStreamUpdateCaptureDependencies"],[5,3,1,"","cuStreamWaitEvent"],[5,3,1,"","cuStreamWaitValue32"],[5,3,1,"","cuStreamWaitValue32_v2"],[5,3,1,"","cuStreamWaitValue64"],[5,3,1,"","cuStreamWaitValue64_v2"],[5,3,1,"","cuStreamWriteValue32"],[5,3,1,"","cuStreamWriteValue32_v2"],[5,3,1,"","cuStreamWriteValue64"],[5,3,1,"","cuStreamWriteValue64_v2"],[5,3,1,"","cuSurfObjectCreate"],[5,3,1,"","cuSurfObjectDestroy"],[5,3,1,"","cuSurfObjectGetResourceDesc"],[5,3,1,"","cuTexObjectCreate"],[5,3,1,"","cuTexObjectDestroy"],[5,3,1,"","cuTexObjectGetResourceDesc"],[5,3,1,"","cuTexObjectGetResourceViewDesc"],[5,3,1,"","cuTexObjectGetTextureDesc"],[5,3,1,"","cuThreadExchangeStreamCaptureMode"],[5,3,1,"","cuUserObjectCreate"],[5,3,1,"","cuUserObjectRelease"],[5,3,1,"","cuUserObjectRetain"],[5,3,1,"","cuVDPAUCtxCreate"],[5,3,1,"","cuVDPAUGetDevice"],[5,3,1,"","cuWaitExternalSemaphoresAsync"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR_st":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR_v2":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR_st":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR_v2":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_v1":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_BATCH_MEM_OP_NODE_PARAMS":[[5,0,1,"","count"],[5,0,1,"","ctx"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","paramArray"]],"cuda.cuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st":[[5,0,1,"","count"],[5,0,1,"","ctx"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","paramArray"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS_st":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS_v1":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS_st":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS_v1":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS_st":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS_v1":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_MEMCPY2D":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY2D_st":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY2D_v2":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY3D":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER_st":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER_v1":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_st":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_v2":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS_st":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS_v1":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEM_ALLOC_NODE_PARAMS":[[5,0,1,"","accessDescCount"],[5,0,1,"","accessDescs"],[5,0,1,"","bytesize"],[5,0,1,"","dptr"],[5,2,1,"","getPtr"],[5,0,1,"","poolProps"]],"cuda.cuda.CUDA_MEM_ALLOC_NODE_PARAMS_st":[[5,0,1,"","accessDescCount"],[5,0,1,"","accessDescs"],[5,0,1,"","bytesize"],[5,0,1,"","dptr"],[5,2,1,"","getPtr"],[5,0,1,"","poolProps"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS":[[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_RESOURCE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC_st":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC_v1":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_TEXTURE_DESC":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_TEXTURE_DESC_st":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_TEXTURE_DESC_v1":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUGLDeviceList":[[5,0,1,"","CU_GL_DEVICE_LIST_ALL"],[5,0,1,"","CU_GL_DEVICE_LIST_CURRENT_FRAME"],[5,0,1,"","CU_GL_DEVICE_LIST_NEXT_FRAME"]],"cuda.cuda.CUGPUDirectRDMAWritesOrdering":[[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES"],[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE"],[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER"]],"cuda.cuda.CUaccessPolicyWindow":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessPolicyWindow_st":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessPolicyWindow_v1":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessProperty":[[5,0,1,"","CU_ACCESS_PROPERTY_NORMAL"],[5,0,1,"","CU_ACCESS_PROPERTY_PERSISTING"],[5,0,1,"","CU_ACCESS_PROPERTY_STREAMING"]],"cuda.cuda.CUaddress_mode":[[5,0,1,"","CU_TR_ADDRESS_MODE_BORDER"],[5,0,1,"","CU_TR_ADDRESS_MODE_CLAMP"],[5,0,1,"","CU_TR_ADDRESS_MODE_MIRROR"],[5,0,1,"","CU_TR_ADDRESS_MODE_WRAP"]],"cuda.cuda.CUarray":[[5,2,1,"","getPtr"]],"cuda.cuda.CUarrayMapInfo":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarrayMapInfo_st":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarrayMapInfo_v1":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarraySparseSubresourceType":[[5,0,1,"","CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL"],[5,0,1,"","CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL"]],"cuda.cuda.CUarray_cubemap_face":[[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_X"],[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_Y"],[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_Z"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_X"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_Y"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_Z"]],"cuda.cuda.CUarray_format":[[5,0,1,"","CU_AD_FORMAT_BC1_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC1_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC2_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC2_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC3_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC3_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC4_SNORM"],[5,0,1,"","CU_AD_FORMAT_BC4_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC5_SNORM"],[5,0,1,"","CU_AD_FORMAT_BC5_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC6H_SF16"],[5,0,1,"","CU_AD_FORMAT_BC6H_UF16"],[5,0,1,"","CU_AD_FORMAT_BC7_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC7_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_FLOAT"],[5,0,1,"","CU_AD_FORMAT_HALF"],[5,0,1,"","CU_AD_FORMAT_NV12"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT16"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT32"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT8"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X1"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X2"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X4"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X1"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X2"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X4"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X1"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X2"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X4"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X1"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X2"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X4"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT16"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT32"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT8"]],"cuda.cuda.CUclusterSchedulingPolicy":[[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_DEFAULT"],[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING"],[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_SPREAD"]],"cuda.cuda.CUcomputemode":[[5,0,1,"","CU_COMPUTEMODE_DEFAULT"],[5,0,1,"","CU_COMPUTEMODE_EXCLUSIVE_PROCESS"],[5,0,1,"","CU_COMPUTEMODE_PROHIBITED"]],"cuda.cuda.CUcontext":[[5,2,1,"","getPtr"]],"cuda.cuda.CUctx_flags":[[5,0,1,"","CU_CTX_BLOCKING_SYNC"],[5,0,1,"","CU_CTX_FLAGS_MASK"],[5,0,1,"","CU_CTX_LMEM_RESIZE_TO_MAX"],[5,0,1,"","CU_CTX_MAP_HOST"],[5,0,1,"","CU_CTX_SCHED_AUTO"],[5,0,1,"","CU_CTX_SCHED_BLOCKING_SYNC"],[5,0,1,"","CU_CTX_SCHED_MASK"],[5,0,1,"","CU_CTX_SCHED_SPIN"],[5,0,1,"","CU_CTX_SCHED_YIELD"]],"cuda.cuda.CUdevice":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdevice_P2PAttribute":[[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK"]],"cuda.cuda.CUdevice_attribute":[[5,0,1,"","CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CLOCK_RATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_MODE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_ECC_ENABLED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_OVERLAP"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_INTEGRATED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_PITCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_BUS_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TCC_DRIVER"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_WARP_SIZE"]],"cuda.cuda.CUdevice_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdeviceptr":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdeviceptr_v2":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdevprop":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdevprop_st":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdevprop_v1":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdriverProcAddress_flags":[[5,0,1,"","CU_GET_PROC_ADDRESS_DEFAULT"],[5,0,1,"","CU_GET_PROC_ADDRESS_LEGACY_STREAM"],[5,0,1,"","CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM"]],"cuda.cuda.CUeglColorFormat":[[5,0,1,"","CU_EGL_COLOR_FORMAT_A"],[5,0,1,"","CU_EGL_COLOR_FORMAT_ABGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_ARGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_AYUV"],[5,0,1,"","CU_EGL_COLOR_FORMAT_AYUV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_CCCC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_BCCR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CBRC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CCCC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CRBC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_RCCB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_BCCR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_CBRC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_CRBC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_RCCB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BGRA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_L"],[5,0,1,"","CU_EGL_COLOR_FORMAT_MAX"],[5,0,1,"","CU_EGL_COLOR_FORMAT_R"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RGBA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_UYVY_422"],[5,0,1,"","CU_EGL_COLOR_FORMAT_UYVY_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_VYUY"],[5,0,1,"","CU_EGL_COLOR_FORMAT_VYUY_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUVA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUVA_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUYV_422"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUYV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVYU"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVYU_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y_ER"]],"cuda.cuda.CUeglFrame":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglFrameType":[[5,0,1,"","CU_EGL_FRAME_TYPE_ARRAY"],[5,0,1,"","CU_EGL_FRAME_TYPE_PITCH"]],"cuda.cuda.CUeglFrame_st":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglFrame_v1":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglResourceLocationFlags":[[5,0,1,"","CU_EGL_RESOURCE_LOCATION_SYSMEM"],[5,0,1,"","CU_EGL_RESOURCE_LOCATION_VIDMEM"]],"cuda.cuda.CUeglStreamConnection":[[5,2,1,"","getPtr"]],"cuda.cuda.CUevent":[[5,2,1,"","getPtr"]],"cuda.cuda.CUevent_flags":[[5,0,1,"","CU_EVENT_BLOCKING_SYNC"],[5,0,1,"","CU_EVENT_DEFAULT"],[5,0,1,"","CU_EVENT_DISABLE_TIMING"],[5,0,1,"","CU_EVENT_INTERPROCESS"]],"cuda.cuda.CUevent_record_flags":[[5,0,1,"","CU_EVENT_RECORD_DEFAULT"],[5,0,1,"","CU_EVENT_RECORD_EXTERNAL"]],"cuda.cuda.CUevent_sched_flags":[[5,0,1,"","CU_EVENT_SCHED_AUTO"],[5,0,1,"","CU_EVENT_SCHED_BLOCKING_SYNC"],[5,0,1,"","CU_EVENT_SCHED_SPIN"],[5,0,1,"","CU_EVENT_SCHED_YIELD"]],"cuda.cuda.CUevent_wait_flags":[[5,0,1,"","CU_EVENT_WAIT_DEFAULT"],[5,0,1,"","CU_EVENT_WAIT_EXTERNAL"]],"cuda.cuda.CUexecAffinityParam":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinityParam_st":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinityParam_v1":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinitySmCount":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinitySmCount_st":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinitySmCount_v1":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinityType":[[5,0,1,"","CU_EXEC_AFFINITY_TYPE_MAX"],[5,0,1,"","CU_EXEC_AFFINITY_TYPE_SM_COUNT"]],"cuda.cuda.CUexternalMemory":[[5,2,1,"","getPtr"]],"cuda.cuda.CUexternalMemoryHandleType":[[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT"]],"cuda.cuda.CUexternalSemaphore":[[5,2,1,"","getPtr"]],"cuda.cuda.CUexternalSemaphoreHandleType":[[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32"]],"cuda.cuda.CUfilter_mode":[[5,0,1,"","CU_TR_FILTER_MODE_LINEAR"],[5,0,1,"","CU_TR_FILTER_MODE_POINT"]],"cuda.cuda.CUflushGPUDirectRDMAWritesOptions":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST"],[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS"]],"cuda.cuda.CUflushGPUDirectRDMAWritesScope":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES"],[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER"]],"cuda.cuda.CUflushGPUDirectRDMAWritesTarget":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX"]],"cuda.cuda.CUfunc_cache":[[5,0,1,"","CU_FUNC_CACHE_PREFER_EQUAL"],[5,0,1,"","CU_FUNC_CACHE_PREFER_L1"],[5,0,1,"","CU_FUNC_CACHE_PREFER_NONE"],[5,0,1,"","CU_FUNC_CACHE_PREFER_SHARED"]],"cuda.cuda.CUfunction":[[5,2,1,"","getPtr"]],"cuda.cuda.CUfunction_attribute":[[5,0,1,"","CU_FUNC_ATTRIBUTE_BINARY_VERSION"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CACHE_MODE_CA"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK"],[5,0,1,"","CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED"],[5,0,1,"","CU_FUNC_ATTRIBUTE_NUM_REGS"],[5,0,1,"","CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT"],[5,0,1,"","CU_FUNC_ATTRIBUTE_PTX_VERSION"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH"],[5,0,1,"","CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES"]],"cuda.cuda.CUgraph":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphDebugDot_flags":[[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE"]],"cuda.cuda.CUgraphExec":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphExecUpdateResult":[[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_SUCCESS"]],"cuda.cuda.CUgraphInstantiate_flags":[[5,0,1,"","CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH"],[5,0,1,"","CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY"]],"cuda.cuda.CUgraphMem_attribute":[[5,0,1,"","CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT"],[5,0,1,"","CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH"],[5,0,1,"","CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT"],[5,0,1,"","CU_GRAPH_MEM_ATTR_USED_MEM_HIGH"]],"cuda.cuda.CUgraphNode":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphNodeType":[[5,0,1,"","CU_GRAPH_NODE_TYPE_BATCH_MEM_OP"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EMPTY"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EVENT_RECORD"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT"],[5,0,1,"","CU_GRAPH_NODE_TYPE_GRAPH"],[5,0,1,"","CU_GRAPH_NODE_TYPE_HOST"],[5,0,1,"","CU_GRAPH_NODE_TYPE_KERNEL"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEMCPY"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEMSET"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEM_ALLOC"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEM_FREE"],[5,0,1,"","CU_GRAPH_NODE_TYPE_WAIT_EVENT"]],"cuda.cuda.CUgraphicsMapResourceFlags":[[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE"],[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY"],[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD"]],"cuda.cuda.CUgraphicsRegisterFlags":[[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_NONE"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD"]],"cuda.cuda.CUgraphicsResource":[[5,2,1,"","getPtr"]],"cuda.cuda.CUhostFn":[[5,2,1,"","getPtr"]],"cuda.cuda.CUipcEventHandle":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcEventHandle_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcEventHandle_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMem_flags":[[5,0,1,"","CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS"]],"cuda.cuda.CUjitInputType":[[5,0,1,"","CU_JIT_INPUT_CUBIN"],[5,0,1,"","CU_JIT_INPUT_FATBINARY"],[5,0,1,"","CU_JIT_INPUT_LIBRARY"],[5,0,1,"","CU_JIT_INPUT_NVVM"],[5,0,1,"","CU_JIT_INPUT_OBJECT"],[5,0,1,"","CU_JIT_INPUT_PTX"],[5,0,1,"","CU_JIT_NUM_INPUT_TYPES"]],"cuda.cuda.CUjit_cacheMode":[[5,0,1,"","CU_JIT_CACHE_OPTION_CA"],[5,0,1,"","CU_JIT_CACHE_OPTION_CG"],[5,0,1,"","CU_JIT_CACHE_OPTION_NONE"]],"cuda.cuda.CUjit_fallback":[[5,0,1,"","CU_PREFER_BINARY"],[5,0,1,"","CU_PREFER_PTX"]],"cuda.cuda.CUjit_option":[[5,0,1,"","CU_JIT_CACHE_MODE"],[5,0,1,"","CU_JIT_ERROR_LOG_BUFFER"],[5,0,1,"","CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES"],[5,0,1,"","CU_JIT_FALLBACK_STRATEGY"],[5,0,1,"","CU_JIT_FAST_COMPILE"],[5,0,1,"","CU_JIT_FMA"],[5,0,1,"","CU_JIT_FTZ"],[5,0,1,"","CU_JIT_GENERATE_DEBUG_INFO"],[5,0,1,"","CU_JIT_GENERATE_LINE_INFO"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_ADDRESSES"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_COUNT"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_NAMES"],[5,0,1,"","CU_JIT_INFO_LOG_BUFFER"],[5,0,1,"","CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES"],[5,0,1,"","CU_JIT_LOG_VERBOSE"],[5,0,1,"","CU_JIT_LTO"],[5,0,1,"","CU_JIT_MAX_REGISTERS"],[5,0,1,"","CU_JIT_NEW_SM3X_OPT"],[5,0,1,"","CU_JIT_NUM_OPTIONS"],[5,0,1,"","CU_JIT_OPTIMIZATION_LEVEL"],[5,0,1,"","CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES"],[5,0,1,"","CU_JIT_PREC_DIV"],[5,0,1,"","CU_JIT_PREC_SQRT"],[5,0,1,"","CU_JIT_REFERENCED_KERNEL_COUNT"],[5,0,1,"","CU_JIT_REFERENCED_KERNEL_NAMES"],[5,0,1,"","CU_JIT_REFERENCED_VARIABLE_COUNT"],[5,0,1,"","CU_JIT_REFERENCED_VARIABLE_NAMES"],[5,0,1,"","CU_JIT_TARGET"],[5,0,1,"","CU_JIT_TARGET_FROM_CUCONTEXT"],[5,0,1,"","CU_JIT_THREADS_PER_BLOCK"],[5,0,1,"","CU_JIT_WALL_TIME"]],"cuda.cuda.CUjit_target":[[5,0,1,"","CU_TARGET_COMPUTE_20"],[5,0,1,"","CU_TARGET_COMPUTE_21"],[5,0,1,"","CU_TARGET_COMPUTE_30"],[5,0,1,"","CU_TARGET_COMPUTE_32"],[5,0,1,"","CU_TARGET_COMPUTE_35"],[5,0,1,"","CU_TARGET_COMPUTE_37"],[5,0,1,"","CU_TARGET_COMPUTE_50"],[5,0,1,"","CU_TARGET_COMPUTE_52"],[5,0,1,"","CU_TARGET_COMPUTE_53"],[5,0,1,"","CU_TARGET_COMPUTE_60"],[5,0,1,"","CU_TARGET_COMPUTE_61"],[5,0,1,"","CU_TARGET_COMPUTE_62"],[5,0,1,"","CU_TARGET_COMPUTE_70"],[5,0,1,"","CU_TARGET_COMPUTE_72"],[5,0,1,"","CU_TARGET_COMPUTE_75"],[5,0,1,"","CU_TARGET_COMPUTE_80"],[5,0,1,"","CU_TARGET_COMPUTE_86"],[5,0,1,"","CU_TARGET_COMPUTE_87"],[5,0,1,"","CU_TARGET_COMPUTE_89"],[5,0,1,"","CU_TARGET_COMPUTE_90"]],"cuda.cuda.CUkernelNodeAttrValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUkernelNodeAttrValue_v1":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttribute":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","value"]],"cuda.cuda.CUlaunchAttributeValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttributeValue_union":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttribute_st":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","value"]],"cuda.cuda.CUlaunchConfig":[[5,0,1,"","attrs"],[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","numAttrs"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUlaunchConfig_st":[[5,0,1,"","attrs"],[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","numAttrs"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUlimit":[[5,0,1,"","CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT"],[5,0,1,"","CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH"],[5,0,1,"","CU_LIMIT_MALLOC_HEAP_SIZE"],[5,0,1,"","CU_LIMIT_MAX"],[5,0,1,"","CU_LIMIT_MAX_L2_FETCH_GRANULARITY"],[5,0,1,"","CU_LIMIT_PERSISTING_L2_CACHE_SIZE"],[5,0,1,"","CU_LIMIT_PRINTF_FIFO_SIZE"],[5,0,1,"","CU_LIMIT_STACK_SIZE"]],"cuda.cuda.CUlinkState":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemAccessDesc":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccessDesc_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccessDesc_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccess_flags":[[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_MAX"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_NONE"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_READ"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_READWRITE"]],"cuda.cuda.CUmemAllocationCompType":[[5,0,1,"","CU_MEM_ALLOCATION_COMP_GENERIC"],[5,0,1,"","CU_MEM_ALLOCATION_COMP_NONE"]],"cuda.cuda.CUmemAllocationGranularity_flags":[[5,0,1,"","CU_MEM_ALLOC_GRANULARITY_MINIMUM"],[5,0,1,"","CU_MEM_ALLOC_GRANULARITY_RECOMMENDED"]],"cuda.cuda.CUmemAllocationHandleType":[[5,0,1,"","CU_MEM_HANDLE_TYPE_MAX"],[5,0,1,"","CU_MEM_HANDLE_TYPE_NONE"],[5,0,1,"","CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR"],[5,0,1,"","CU_MEM_HANDLE_TYPE_WIN32"],[5,0,1,"","CU_MEM_HANDLE_TYPE_WIN32_KMT"]],"cuda.cuda.CUmemAllocationProp":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationProp_st":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationProp_v1":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationType":[[5,0,1,"","CU_MEM_ALLOCATION_TYPE_INVALID"],[5,0,1,"","CU_MEM_ALLOCATION_TYPE_MAX"],[5,0,1,"","CU_MEM_ALLOCATION_TYPE_PINNED"]],"cuda.cuda.CUmemAttach_flags":[[5,0,1,"","CU_MEM_ATTACH_GLOBAL"],[5,0,1,"","CU_MEM_ATTACH_HOST"],[5,0,1,"","CU_MEM_ATTACH_SINGLE"]],"cuda.cuda.CUmemGenericAllocationHandle":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemGenericAllocationHandle_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemHandleType":[[5,0,1,"","CU_MEM_HANDLE_TYPE_GENERIC"]],"cuda.cuda.CUmemLocation":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemLocationType":[[5,0,1,"","CU_MEM_LOCATION_TYPE_DEVICE"],[5,0,1,"","CU_MEM_LOCATION_TYPE_INVALID"],[5,0,1,"","CU_MEM_LOCATION_TYPE_MAX"]],"cuda.cuda.CUmemLocation_st":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemLocation_v1":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemOperationType":[[5,0,1,"","CU_MEM_OPERATION_TYPE_MAP"],[5,0,1,"","CU_MEM_OPERATION_TYPE_UNMAP"]],"cuda.cuda.CUmemPoolProps":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolProps_st":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolProps_v1":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolPtrExportData":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPoolPtrExportData_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPoolPtrExportData_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPool_attribute":[[5,0,1,"","CU_MEMPOOL_ATTR_RELEASE_THRESHOLD"],[5,0,1,"","CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT"],[5,0,1,"","CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES"],[5,0,1,"","CU_MEMPOOL_ATTR_USED_MEM_CURRENT"],[5,0,1,"","CU_MEMPOOL_ATTR_USED_MEM_HIGH"]],"cuda.cuda.CUmemRangeHandleType":[[5,0,1,"","CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD"],[5,0,1,"","CU_MEM_RANGE_HANDLE_TYPE_MAX"]],"cuda.cuda.CUmem_advise":[[5,0,1,"","CU_MEM_ADVISE_SET_ACCESSED_BY"],[5,0,1,"","CU_MEM_ADVISE_SET_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_ADVISE_SET_READ_MOSTLY"],[5,0,1,"","CU_MEM_ADVISE_UNSET_ACCESSED_BY"],[5,0,1,"","CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_ADVISE_UNSET_READ_MOSTLY"]],"cuda.cuda.CUmem_range_attribute":[[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY"]],"cuda.cuda.CUmemoryPool":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemorytype":[[5,0,1,"","CU_MEMORYTYPE_ARRAY"],[5,0,1,"","CU_MEMORYTYPE_DEVICE"],[5,0,1,"","CU_MEMORYTYPE_HOST"],[5,0,1,"","CU_MEMORYTYPE_UNIFIED"]],"cuda.cuda.CUmipmappedArray":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmodule":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmoduleLoadingMode":[[5,0,1,"","CU_MODULE_EAGER_LOADING"],[5,0,1,"","CU_MODULE_LAZY_LOADING"]],"cuda.cuda.CUoccupancyB2DSize":[[5,2,1,"","getPtr"]],"cuda.cuda.CUoccupancy_flags":[[5,0,1,"","CU_OCCUPANCY_DEFAULT"],[5,0,1,"","CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE"]],"cuda.cuda.CUpointer_attribute":[[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAGS"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES"],[5,0,1,"","CU_POINTER_ATTRIBUTE_BUFFER_ID"],[5,0,1,"","CU_POINTER_ATTRIBUTE_CONTEXT"],[5,0,1,"","CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL"],[5,0,1,"","CU_POINTER_ATTRIBUTE_DEVICE_POINTER"],[5,0,1,"","CU_POINTER_ATTRIBUTE_HOST_POINTER"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_MANAGED"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPED"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPING_SIZE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMORY_TYPE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_P2P_TOKENS"],[5,0,1,"","CU_POINTER_ATTRIBUTE_RANGE_SIZE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_RANGE_START_ADDR"],[5,0,1,"","CU_POINTER_ATTRIBUTE_SYNC_MEMOPS"]],"cuda.cuda.CUresourceViewFormat":[[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_NONE"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC4"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC5"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC6H"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC1"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC2"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC3"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC4"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC5"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC6H"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC7"]],"cuda.cuda.CUresourcetype":[[5,0,1,"","CU_RESOURCE_TYPE_ARRAY"],[5,0,1,"","CU_RESOURCE_TYPE_LINEAR"],[5,0,1,"","CU_RESOURCE_TYPE_MIPMAPPED_ARRAY"],[5,0,1,"","CU_RESOURCE_TYPE_PITCH2D"]],"cuda.cuda.CUresult":[[5,0,1,"","CUDA_ERROR_ALREADY_ACQUIRED"],[5,0,1,"","CUDA_ERROR_ALREADY_MAPPED"],[5,0,1,"","CUDA_ERROR_ARRAY_IS_MAPPED"],[5,0,1,"","CUDA_ERROR_ASSERT"],[5,0,1,"","CUDA_ERROR_CAPTURED_EVENT"],[5,0,1,"","CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE"],[5,0,1,"","CUDA_ERROR_CONTEXT_ALREADY_CURRENT"],[5,0,1,"","CUDA_ERROR_CONTEXT_ALREADY_IN_USE"],[5,0,1,"","CUDA_ERROR_CONTEXT_IS_DESTROYED"],[5,0,1,"","CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE"],[5,0,1,"","CUDA_ERROR_DEINITIALIZED"],[5,0,1,"","CUDA_ERROR_DEVICE_NOT_LICENSED"],[5,0,1,"","CUDA_ERROR_DEVICE_UNAVAILABLE"],[5,0,1,"","CUDA_ERROR_ECC_UNCORRECTABLE"],[5,0,1,"","CUDA_ERROR_EXTERNAL_DEVICE"],[5,0,1,"","CUDA_ERROR_FILE_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE"],[5,0,1,"","CUDA_ERROR_HARDWARE_STACK_ERROR"],[5,0,1,"","CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED"],[5,0,1,"","CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED"],[5,0,1,"","CUDA_ERROR_ILLEGAL_ADDRESS"],[5,0,1,"","CUDA_ERROR_ILLEGAL_INSTRUCTION"],[5,0,1,"","CUDA_ERROR_ILLEGAL_STATE"],[5,0,1,"","CUDA_ERROR_INVALID_ADDRESS_SPACE"],[5,0,1,"","CUDA_ERROR_INVALID_CLUSTER_SIZE"],[5,0,1,"","CUDA_ERROR_INVALID_CONTEXT"],[5,0,1,"","CUDA_ERROR_INVALID_DEVICE"],[5,0,1,"","CUDA_ERROR_INVALID_GRAPHICS_CONTEXT"],[5,0,1,"","CUDA_ERROR_INVALID_HANDLE"],[5,0,1,"","CUDA_ERROR_INVALID_IMAGE"],[5,0,1,"","CUDA_ERROR_INVALID_PC"],[5,0,1,"","CUDA_ERROR_INVALID_PTX"],[5,0,1,"","CUDA_ERROR_INVALID_SOURCE"],[5,0,1,"","CUDA_ERROR_INVALID_VALUE"],[5,0,1,"","CUDA_ERROR_JIT_COMPILATION_DISABLED"],[5,0,1,"","CUDA_ERROR_JIT_COMPILER_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_LAUNCH_FAILED"],[5,0,1,"","CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING"],[5,0,1,"","CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES"],[5,0,1,"","CUDA_ERROR_LAUNCH_TIMEOUT"],[5,0,1,"","CUDA_ERROR_MAP_FAILED"],[5,0,1,"","CUDA_ERROR_MISALIGNED_ADDRESS"],[5,0,1,"","CUDA_ERROR_MPS_CLIENT_TERMINATED"],[5,0,1,"","CUDA_ERROR_MPS_CONNECTION_FAILED"],[5,0,1,"","CUDA_ERROR_MPS_MAX_CLIENTS_REACHED"],[5,0,1,"","CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED"],[5,0,1,"","CUDA_ERROR_MPS_RPC_FAILURE"],[5,0,1,"","CUDA_ERROR_MPS_SERVER_NOT_READY"],[5,0,1,"","CUDA_ERROR_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_NOT_INITIALIZED"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED_AS_ARRAY"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED_AS_POINTER"],[5,0,1,"","CUDA_ERROR_NOT_PERMITTED"],[5,0,1,"","CUDA_ERROR_NOT_READY"],[5,0,1,"","CUDA_ERROR_NOT_SUPPORTED"],[5,0,1,"","CUDA_ERROR_NO_BINARY_FOR_GPU"],[5,0,1,"","CUDA_ERROR_NO_DEVICE"],[5,0,1,"","CUDA_ERROR_NVLINK_UNCORRECTABLE"],[5,0,1,"","CUDA_ERROR_OPERATING_SYSTEM"],[5,0,1,"","CUDA_ERROR_OUT_OF_MEMORY"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_NOT_ENABLED"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_UNSUPPORTED"],[5,0,1,"","CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE"],[5,0,1,"","CUDA_ERROR_PROFILER_ALREADY_STARTED"],[5,0,1,"","CUDA_ERROR_PROFILER_ALREADY_STOPPED"],[5,0,1,"","CUDA_ERROR_PROFILER_DISABLED"],[5,0,1,"","CUDA_ERROR_PROFILER_NOT_INITIALIZED"],[5,0,1,"","CUDA_ERROR_SHARED_OBJECT_INIT_FAILED"],[5,0,1,"","CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_IMPLICIT"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_INVALIDATED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_ISOLATION"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_MERGE"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNJOINED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNMATCHED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD"],[5,0,1,"","CUDA_ERROR_STUB_LIBRARY"],[5,0,1,"","CUDA_ERROR_SYSTEM_DRIVER_MISMATCH"],[5,0,1,"","CUDA_ERROR_SYSTEM_NOT_READY"],[5,0,1,"","CUDA_ERROR_TIMEOUT"],[5,0,1,"","CUDA_ERROR_TOO_MANY_PEERS"],[5,0,1,"","CUDA_ERROR_UNKNOWN"],[5,0,1,"","CUDA_ERROR_UNMAP_FAILED"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_LIMIT"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_PTX_VERSION"],[5,0,1,"","CUDA_SUCCESS"]],"cuda.cuda.CUshared_carveout":[[5,0,1,"","CU_SHAREDMEM_CARVEOUT_DEFAULT"],[5,0,1,"","CU_SHAREDMEM_CARVEOUT_MAX_L1"],[5,0,1,"","CU_SHAREDMEM_CARVEOUT_MAX_SHARED"]],"cuda.cuda.CUsharedconfig":[[5,0,1,"","CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE"],[5,0,1,"","CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE"],[5,0,1,"","CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE"]],"cuda.cuda.CUstream":[[5,2,1,"","getPtr"]],"cuda.cuda.CUstreamAttrID":[[5,0,1,"","CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_COOPERATIVE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_IGNORE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PRIORITY"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY"]],"cuda.cuda.CUstreamAttrValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUstreamAttrValue_v1":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUstreamBatchMemOpParams":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpParams_union":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpParams_v1":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpType":[[5,0,1,"","CU_STREAM_MEM_OP_BARRIER"],[5,0,1,"","CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES"],[5,0,1,"","CU_STREAM_MEM_OP_WAIT_VALUE_32"],[5,0,1,"","CU_STREAM_MEM_OP_WAIT_VALUE_64"],[5,0,1,"","CU_STREAM_MEM_OP_WRITE_VALUE_32"],[5,0,1,"","CU_STREAM_MEM_OP_WRITE_VALUE_64"]],"cuda.cuda.CUstreamCallback":[[5,2,1,"","getPtr"]],"cuda.cuda.CUstreamCaptureMode":[[5,0,1,"","CU_STREAM_CAPTURE_MODE_GLOBAL"],[5,0,1,"","CU_STREAM_CAPTURE_MODE_RELAXED"],[5,0,1,"","CU_STREAM_CAPTURE_MODE_THREAD_LOCAL"]],"cuda.cuda.CUstreamCaptureStatus":[[5,0,1,"","CU_STREAM_CAPTURE_STATUS_ACTIVE"],[5,0,1,"","CU_STREAM_CAPTURE_STATUS_INVALIDATED"],[5,0,1,"","CU_STREAM_CAPTURE_STATUS_NONE"]],"cuda.cuda.CUstreamMemoryBarrier_flags":[[5,0,1,"","CU_STREAM_MEMORY_BARRIER_TYPE_GPU"],[5,0,1,"","CU_STREAM_MEMORY_BARRIER_TYPE_SYS"]],"cuda.cuda.CUstreamUpdateCaptureDependencies_flags":[[5,0,1,"","CU_STREAM_ADD_CAPTURE_DEPENDENCIES"],[5,0,1,"","CU_STREAM_SET_CAPTURE_DEPENDENCIES"]],"cuda.cuda.CUstreamWaitValue_flags":[[5,0,1,"","CU_STREAM_WAIT_VALUE_AND"],[5,0,1,"","CU_STREAM_WAIT_VALUE_EQ"],[5,0,1,"","CU_STREAM_WAIT_VALUE_FLUSH"],[5,0,1,"","CU_STREAM_WAIT_VALUE_GEQ"],[5,0,1,"","CU_STREAM_WAIT_VALUE_NOR"]],"cuda.cuda.CUstreamWriteValue_flags":[[5,0,1,"","CU_STREAM_WRITE_VALUE_DEFAULT"],[5,0,1,"","CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER"]],"cuda.cuda.CUstream_flags":[[5,0,1,"","CU_STREAM_DEFAULT"],[5,0,1,"","CU_STREAM_NON_BLOCKING"]],"cuda.cuda.CUsurfObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsurfObject_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsurfref":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsynchronizationPolicy":[[5,0,1,"","CU_SYNC_POLICY_AUTO"],[5,0,1,"","CU_SYNC_POLICY_BLOCKING_SYNC"],[5,0,1,"","CU_SYNC_POLICY_SPIN"],[5,0,1,"","CU_SYNC_POLICY_YIELD"]],"cuda.cuda.CUtexObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUtexObject_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUtexref":[[5,2,1,"","getPtr"]],"cuda.cuda.CUuserObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUuserObjectRetain_flags":[[5,0,1,"","CU_GRAPH_USER_OBJECT_MOVE"]],"cuda.cuda.CUuserObject_flags":[[5,0,1,"","CU_USER_OBJECT_NO_DESTRUCTOR_SYNC"]],"cuda.cuda.CUuuid":[[5,0,1,"","bytes"],[5,2,1,"","getPtr"]],"cuda.cuda.CUuuid_st":[[5,0,1,"","bytes"],[5,2,1,"","getPtr"]],"cuda.cuda.cl_context_flags":[[5,0,1,"","NVCL_CTX_SCHED_AUTO"],[5,0,1,"","NVCL_CTX_SCHED_BLOCKING_SYNC"],[5,0,1,"","NVCL_CTX_SCHED_SPIN"],[5,0,1,"","NVCL_CTX_SCHED_YIELD"]],"cuda.cuda.cl_event_flags":[[5,0,1,"","NVCL_EVENT_SCHED_AUTO"],[5,0,1,"","NVCL_EVENT_SCHED_BLOCKING_SYNC"],[5,0,1,"","NVCL_EVENT_SCHED_SPIN"],[5,0,1,"","NVCL_EVENT_SCHED_YIELD"]],"cuda.cudart":[[6,0,1,"","CUDA_EGL_MAX_PLANES"],[6,0,1,"","CUDA_IPC_HANDLE_SIZE"],[6,1,1,"","CUuuid"],[6,1,1,"","CUuuid_st"],[6,1,1,"","cudaAccessPolicyWindow"],[6,1,1,"","cudaAccessProperty"],[6,0,1,"","cudaArrayColorAttachment"],[6,0,1,"","cudaArrayCubemap"],[6,0,1,"","cudaArrayDefault"],[6,0,1,"","cudaArrayDeferredMapping"],[6,3,1,"","cudaArrayGetInfo"],[6,3,1,"","cudaArrayGetMemoryRequirements"],[6,3,1,"","cudaArrayGetPlane"],[6,3,1,"","cudaArrayGetSparseProperties"],[6,0,1,"","cudaArrayLayered"],[6,1,1,"","cudaArrayMemoryRequirements"],[6,0,1,"","cudaArraySparse"],[6,1,1,"","cudaArraySparseProperties"],[6,0,1,"","cudaArraySparsePropertiesSingleMipTail"],[6,0,1,"","cudaArraySurfaceLoadStore"],[6,0,1,"","cudaArrayTextureGather"],[6,1,1,"","cudaArray_const_t"],[6,1,1,"","cudaArray_t"],[6,1,1,"","cudaCGScope"],[6,1,1,"","cudaChannelFormatDesc"],[6,1,1,"","cudaChannelFormatKind"],[6,3,1,"","cudaChooseDevice"],[6,1,1,"","cudaClusterSchedulingPolicy"],[6,1,1,"","cudaComputeMode"],[6,0,1,"","cudaCooperativeLaunchMultiDeviceNoPostSync"],[6,0,1,"","cudaCooperativeLaunchMultiDeviceNoPreSync"],[6,0,1,"","cudaCpuDeviceId"],[6,3,1,"","cudaCreateChannelDesc"],[6,3,1,"","cudaCreateSurfaceObject"],[6,3,1,"","cudaCreateTextureObject"],[6,3,1,"","cudaCreateTextureObject_v2"],[6,3,1,"","cudaCtxResetPersistingL2Cache"],[6,3,1,"","cudaDestroyExternalMemory"],[6,3,1,"","cudaDestroyExternalSemaphore"],[6,3,1,"","cudaDestroySurfaceObject"],[6,3,1,"","cudaDestroyTextureObject"],[6,1,1,"","cudaDeviceAttr"],[6,0,1,"","cudaDeviceBlockingSync"],[6,3,1,"","cudaDeviceCanAccessPeer"],[6,3,1,"","cudaDeviceDisablePeerAccess"],[6,3,1,"","cudaDeviceEnablePeerAccess"],[6,3,1,"","cudaDeviceFlushGPUDirectRDMAWrites"],[6,3,1,"","cudaDeviceGetAttribute"],[6,3,1,"","cudaDeviceGetByPCIBusId"],[6,3,1,"","cudaDeviceGetCacheConfig"],[6,3,1,"","cudaDeviceGetDefaultMemPool"],[6,3,1,"","cudaDeviceGetGraphMemAttribute"],[6,3,1,"","cudaDeviceGetLimit"],[6,3,1,"","cudaDeviceGetMemPool"],[6,3,1,"","cudaDeviceGetNvSciSyncAttributes"],[6,3,1,"","cudaDeviceGetP2PAttribute"],[6,3,1,"","cudaDeviceGetPCIBusId"],[6,3,1,"","cudaDeviceGetSharedMemConfig"],[6,3,1,"","cudaDeviceGetStreamPriorityRange"],[6,3,1,"","cudaDeviceGetTexture1DLinearMaxWidth"],[6,3,1,"","cudaDeviceGraphMemTrim"],[6,0,1,"","cudaDeviceLmemResizeToMax"],[6,0,1,"","cudaDeviceMapHost"],[6,0,1,"","cudaDeviceMask"],[6,1,1,"","cudaDeviceP2PAttr"],[6,1,1,"","cudaDeviceProp"],[6,3,1,"","cudaDeviceReset"],[6,0,1,"","cudaDeviceScheduleAuto"],[6,0,1,"","cudaDeviceScheduleBlockingSync"],[6,0,1,"","cudaDeviceScheduleMask"],[6,0,1,"","cudaDeviceScheduleSpin"],[6,0,1,"","cudaDeviceScheduleYield"],[6,3,1,"","cudaDeviceSetCacheConfig"],[6,3,1,"","cudaDeviceSetGraphMemAttribute"],[6,3,1,"","cudaDeviceSetLimit"],[6,3,1,"","cudaDeviceSetMemPool"],[6,3,1,"","cudaDeviceSetSharedMemConfig"],[6,3,1,"","cudaDeviceSynchronize"],[6,3,1,"","cudaDriverGetVersion"],[6,3,1,"","cudaEGLStreamConsumerAcquireFrame"],[6,3,1,"","cudaEGLStreamConsumerConnect"],[6,3,1,"","cudaEGLStreamConsumerConnectWithFlags"],[6,3,1,"","cudaEGLStreamConsumerDisconnect"],[6,3,1,"","cudaEGLStreamConsumerReleaseFrame"],[6,3,1,"","cudaEGLStreamProducerConnect"],[6,3,1,"","cudaEGLStreamProducerDisconnect"],[6,3,1,"","cudaEGLStreamProducerPresentFrame"],[6,3,1,"","cudaEGLStreamProducerReturnFrame"],[6,1,1,"","cudaEglColorFormat"],[6,1,1,"","cudaEglFrame"],[6,1,1,"","cudaEglFrameType"],[6,1,1,"","cudaEglFrame_st"],[6,1,1,"","cudaEglPlaneDesc"],[6,1,1,"","cudaEglPlaneDesc_st"],[6,1,1,"","cudaEglResourceLocationFlags"],[6,1,1,"","cudaEglStreamConnection"],[6,1,1,"","cudaError_t"],[6,0,1,"","cudaEventBlockingSync"],[6,3,1,"","cudaEventCreate"],[6,3,1,"","cudaEventCreateFromEGLSync"],[6,3,1,"","cudaEventCreateWithFlags"],[6,0,1,"","cudaEventDefault"],[6,3,1,"","cudaEventDestroy"],[6,0,1,"","cudaEventDisableTiming"],[6,3,1,"","cudaEventElapsedTime"],[6,0,1,"","cudaEventInterprocess"],[6,3,1,"","cudaEventQuery"],[6,3,1,"","cudaEventRecord"],[6,0,1,"","cudaEventRecordDefault"],[6,0,1,"","cudaEventRecordExternal"],[6,3,1,"","cudaEventRecordWithFlags"],[6,3,1,"","cudaEventSynchronize"],[6,0,1,"","cudaEventWaitDefault"],[6,0,1,"","cudaEventWaitExternal"],[6,1,1,"","cudaEvent_t"],[6,1,1,"","cudaExtent"],[6,1,1,"","cudaExternalMemoryBufferDesc"],[6,0,1,"","cudaExternalMemoryDedicated"],[6,3,1,"","cudaExternalMemoryGetMappedBuffer"],[6,3,1,"","cudaExternalMemoryGetMappedMipmappedArray"],[6,1,1,"","cudaExternalMemoryHandleDesc"],[6,1,1,"","cudaExternalMemoryHandleType"],[6,1,1,"","cudaExternalMemoryMipmappedArrayDesc"],[6,1,1,"","cudaExternalMemory_t"],[6,1,1,"","cudaExternalSemaphoreHandleDesc"],[6,1,1,"","cudaExternalSemaphoreHandleType"],[6,1,1,"","cudaExternalSemaphoreSignalNodeParams"],[6,1,1,"","cudaExternalSemaphoreSignalParams"],[6,0,1,"","cudaExternalSemaphoreSignalSkipNvSciBufMemSync"],[6,1,1,"","cudaExternalSemaphoreWaitNodeParams"],[6,1,1,"","cudaExternalSemaphoreWaitParams"],[6,0,1,"","cudaExternalSemaphoreWaitSkipNvSciBufMemSync"],[6,1,1,"","cudaExternalSemaphore_t"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesOptions"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesScope"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesTarget"],[6,3,1,"","cudaFree"],[6,3,1,"","cudaFreeArray"],[6,3,1,"","cudaFreeAsync"],[6,3,1,"","cudaFreeHost"],[6,3,1,"","cudaFreeMipmappedArray"],[6,1,1,"","cudaFuncAttribute"],[6,1,1,"","cudaFuncAttributes"],[6,1,1,"","cudaFuncCache"],[6,3,1,"","cudaFuncGetAttributes"],[6,3,1,"","cudaFuncSetAttribute"],[6,3,1,"","cudaFuncSetCacheConfig"],[6,3,1,"","cudaFuncSetSharedMemConfig"],[6,1,1,"","cudaFunction_t"],[6,1,1,"","cudaGLDeviceList"],[6,3,1,"","cudaGLGetDevices"],[6,1,1,"","cudaGPUDirectRDMAWritesOrdering"],[6,3,1,"","cudaGetChannelDesc"],[6,3,1,"","cudaGetDevice"],[6,3,1,"","cudaGetDeviceCount"],[6,3,1,"","cudaGetDeviceFlags"],[6,3,1,"","cudaGetDeviceProperties"],[6,3,1,"","cudaGetDriverEntryPoint"],[6,1,1,"","cudaGetDriverEntryPointFlags"],[6,3,1,"","cudaGetErrorName"],[6,3,1,"","cudaGetErrorString"],[6,3,1,"","cudaGetLastError"],[6,3,1,"","cudaGetMipmappedArrayLevel"],[6,3,1,"","cudaGetSurfaceObjectResourceDesc"],[6,3,1,"","cudaGetTextureObjectResourceDesc"],[6,3,1,"","cudaGetTextureObjectResourceViewDesc"],[6,3,1,"","cudaGetTextureObjectTextureDesc"],[6,3,1,"","cudaGetTextureObjectTextureDesc_v2"],[6,3,1,"","cudaGraphAddChildGraphNode"],[6,3,1,"","cudaGraphAddDependencies"],[6,3,1,"","cudaGraphAddEmptyNode"],[6,3,1,"","cudaGraphAddEventRecordNode"],[6,3,1,"","cudaGraphAddEventWaitNode"],[6,3,1,"","cudaGraphAddExternalSemaphoresSignalNode"],[6,3,1,"","cudaGraphAddExternalSemaphoresWaitNode"],[6,3,1,"","cudaGraphAddHostNode"],[6,3,1,"","cudaGraphAddKernelNode"],[6,3,1,"","cudaGraphAddMemAllocNode"],[6,3,1,"","cudaGraphAddMemFreeNode"],[6,3,1,"","cudaGraphAddMemcpyNode"],[6,3,1,"","cudaGraphAddMemcpyNode1D"],[6,3,1,"","cudaGraphAddMemsetNode"],[6,3,1,"","cudaGraphChildGraphNodeGetGraph"],[6,3,1,"","cudaGraphClone"],[6,3,1,"","cudaGraphCreate"],[6,1,1,"","cudaGraphDebugDotFlags"],[6,3,1,"","cudaGraphDebugDotPrint"],[6,3,1,"","cudaGraphDestroy"],[6,3,1,"","cudaGraphDestroyNode"],[6,3,1,"","cudaGraphEventRecordNodeGetEvent"],[6,3,1,"","cudaGraphEventRecordNodeSetEvent"],[6,3,1,"","cudaGraphEventWaitNodeGetEvent"],[6,3,1,"","cudaGraphEventWaitNodeSetEvent"],[6,3,1,"","cudaGraphExecChildGraphNodeSetParams"],[6,3,1,"","cudaGraphExecDestroy"],[6,3,1,"","cudaGraphExecEventRecordNodeSetEvent"],[6,3,1,"","cudaGraphExecEventWaitNodeSetEvent"],[6,3,1,"","cudaGraphExecExternalSemaphoresSignalNodeSetParams"],[6,3,1,"","cudaGraphExecExternalSemaphoresWaitNodeSetParams"],[6,3,1,"","cudaGraphExecHostNodeSetParams"],[6,3,1,"","cudaGraphExecKernelNodeSetParams"],[6,3,1,"","cudaGraphExecMemcpyNodeSetParams"],[6,3,1,"","cudaGraphExecMemcpyNodeSetParams1D"],[6,3,1,"","cudaGraphExecMemsetNodeSetParams"],[6,3,1,"","cudaGraphExecUpdate"],[6,1,1,"","cudaGraphExecUpdateResult"],[6,1,1,"","cudaGraphExec_t"],[6,3,1,"","cudaGraphExternalSemaphoresSignalNodeGetParams"],[6,3,1,"","cudaGraphExternalSemaphoresSignalNodeSetParams"],[6,3,1,"","cudaGraphExternalSemaphoresWaitNodeGetParams"],[6,3,1,"","cudaGraphExternalSemaphoresWaitNodeSetParams"],[6,3,1,"","cudaGraphGetEdges"],[6,3,1,"","cudaGraphGetNodes"],[6,3,1,"","cudaGraphGetRootNodes"],[6,3,1,"","cudaGraphHostNodeGetParams"],[6,3,1,"","cudaGraphHostNodeSetParams"],[6,3,1,"","cudaGraphInstantiate"],[6,1,1,"","cudaGraphInstantiateFlags"],[6,3,1,"","cudaGraphInstantiateWithFlags"],[6,3,1,"","cudaGraphKernelNodeCopyAttributes"],[6,3,1,"","cudaGraphKernelNodeGetAttribute"],[6,3,1,"","cudaGraphKernelNodeGetParams"],[6,3,1,"","cudaGraphKernelNodeSetAttribute"],[6,3,1,"","cudaGraphKernelNodeSetParams"],[6,3,1,"","cudaGraphLaunch"],[6,3,1,"","cudaGraphMemAllocNodeGetParams"],[6,1,1,"","cudaGraphMemAttributeType"],[6,3,1,"","cudaGraphMemFreeNodeGetParams"],[6,3,1,"","cudaGraphMemcpyNodeGetParams"],[6,3,1,"","cudaGraphMemcpyNodeSetParams"],[6,3,1,"","cudaGraphMemcpyNodeSetParams1D"],[6,3,1,"","cudaGraphMemsetNodeGetParams"],[6,3,1,"","cudaGraphMemsetNodeSetParams"],[6,3,1,"","cudaGraphNodeFindInClone"],[6,3,1,"","cudaGraphNodeGetDependencies"],[6,3,1,"","cudaGraphNodeGetDependentNodes"],[6,3,1,"","cudaGraphNodeGetEnabled"],[6,3,1,"","cudaGraphNodeGetType"],[6,3,1,"","cudaGraphNodeSetEnabled"],[6,1,1,"","cudaGraphNodeType"],[6,1,1,"","cudaGraphNode_t"],[6,3,1,"","cudaGraphReleaseUserObject"],[6,3,1,"","cudaGraphRemoveDependencies"],[6,3,1,"","cudaGraphRetainUserObject"],[6,3,1,"","cudaGraphUpload"],[6,1,1,"","cudaGraph_t"],[6,1,1,"","cudaGraphicsCubeFace"],[6,3,1,"","cudaGraphicsEGLRegisterImage"],[6,3,1,"","cudaGraphicsGLRegisterBuffer"],[6,3,1,"","cudaGraphicsGLRegisterImage"],[6,1,1,"","cudaGraphicsMapFlags"],[6,3,1,"","cudaGraphicsMapResources"],[6,1,1,"","cudaGraphicsRegisterFlags"],[6,3,1,"","cudaGraphicsResourceGetMappedEglFrame"],[6,3,1,"","cudaGraphicsResourceGetMappedMipmappedArray"],[6,3,1,"","cudaGraphicsResourceGetMappedPointer"],[6,3,1,"","cudaGraphicsResourceSetMapFlags"],[6,1,1,"","cudaGraphicsResource_t"],[6,3,1,"","cudaGraphicsSubResourceGetMappedArray"],[6,3,1,"","cudaGraphicsUnmapResources"],[6,3,1,"","cudaGraphicsUnregisterResource"],[6,3,1,"","cudaGraphicsVDPAURegisterOutputSurface"],[6,3,1,"","cudaGraphicsVDPAURegisterVideoSurface"],[6,3,1,"","cudaHostAlloc"],[6,0,1,"","cudaHostAllocDefault"],[6,0,1,"","cudaHostAllocMapped"],[6,0,1,"","cudaHostAllocPortable"],[6,0,1,"","cudaHostAllocWriteCombined"],[6,1,1,"","cudaHostFn_t"],[6,3,1,"","cudaHostGetDevicePointer"],[6,3,1,"","cudaHostGetFlags"],[6,1,1,"","cudaHostNodeParams"],[6,3,1,"","cudaHostRegister"],[6,0,1,"","cudaHostRegisterDefault"],[6,0,1,"","cudaHostRegisterIoMemory"],[6,0,1,"","cudaHostRegisterMapped"],[6,0,1,"","cudaHostRegisterPortable"],[6,0,1,"","cudaHostRegisterReadOnly"],[6,3,1,"","cudaHostUnregister"],[6,3,1,"","cudaImportExternalMemory"],[6,3,1,"","cudaImportExternalSemaphore"],[6,0,1,"","cudaInvalidDeviceId"],[6,3,1,"","cudaIpcCloseMemHandle"],[6,1,1,"","cudaIpcEventHandle_st"],[6,1,1,"","cudaIpcEventHandle_t"],[6,3,1,"","cudaIpcGetEventHandle"],[6,3,1,"","cudaIpcGetMemHandle"],[6,1,1,"","cudaIpcMemHandle_st"],[6,1,1,"","cudaIpcMemHandle_t"],[6,0,1,"","cudaIpcMemLazyEnablePeerAccess"],[6,3,1,"","cudaIpcOpenEventHandle"],[6,3,1,"","cudaIpcOpenMemHandle"],[6,0,1,"","cudaKernelNodeAttrID"],[6,0,1,"","cudaKernelNodeAttrValue"],[6,0,1,"","cudaKernelNodeAttributeClusterDimension"],[6,0,1,"","cudaKernelNodeAttributeClusterSchedulingPolicyPreference"],[6,1,1,"","cudaKernelNodeParams"],[6,1,1,"","cudaLaunchAttribute"],[6,1,1,"","cudaLaunchAttributeID"],[6,1,1,"id0","cudaLaunchAttributeValue"],[6,1,1,"","cudaLaunchAttribute_st"],[6,3,1,"","cudaLaunchHostFunc"],[6,1,1,"","cudaLimit"],[6,3,1,"","cudaMalloc"],[6,3,1,"","cudaMalloc3D"],[6,3,1,"","cudaMalloc3DArray"],[6,3,1,"","cudaMallocArray"],[6,3,1,"","cudaMallocAsync"],[6,3,1,"","cudaMallocFromPoolAsync"],[6,3,1,"","cudaMallocHost"],[6,3,1,"","cudaMallocManaged"],[6,3,1,"","cudaMallocMipmappedArray"],[6,3,1,"","cudaMallocPitch"],[6,1,1,"","cudaMemAccessDesc"],[6,1,1,"","cudaMemAccessFlags"],[6,3,1,"","cudaMemAdvise"],[6,1,1,"","cudaMemAllocNodeParams"],[6,1,1,"","cudaMemAllocationHandleType"],[6,1,1,"","cudaMemAllocationType"],[6,0,1,"","cudaMemAttachGlobal"],[6,0,1,"","cudaMemAttachHost"],[6,0,1,"","cudaMemAttachSingle"],[6,3,1,"","cudaMemGetInfo"],[6,1,1,"","cudaMemLocation"],[6,1,1,"","cudaMemLocationType"],[6,1,1,"","cudaMemPoolAttr"],[6,3,1,"","cudaMemPoolCreate"],[6,3,1,"","cudaMemPoolDestroy"],[6,3,1,"","cudaMemPoolExportPointer"],[6,3,1,"","cudaMemPoolExportToShareableHandle"],[6,3,1,"","cudaMemPoolGetAccess"],[6,3,1,"","cudaMemPoolGetAttribute"],[6,3,1,"","cudaMemPoolImportFromShareableHandle"],[6,3,1,"","cudaMemPoolImportPointer"],[6,1,1,"","cudaMemPoolProps"],[6,1,1,"","cudaMemPoolPtrExportData"],[6,3,1,"","cudaMemPoolSetAccess"],[6,3,1,"","cudaMemPoolSetAttribute"],[6,3,1,"","cudaMemPoolTrimTo"],[6,1,1,"","cudaMemPool_t"],[6,3,1,"","cudaMemPrefetchAsync"],[6,1,1,"","cudaMemRangeAttribute"],[6,3,1,"","cudaMemRangeGetAttribute"],[6,3,1,"","cudaMemRangeGetAttributes"],[6,3,1,"","cudaMemcpy"],[6,3,1,"","cudaMemcpy2D"],[6,3,1,"","cudaMemcpy2DArrayToArray"],[6,3,1,"","cudaMemcpy2DAsync"],[6,3,1,"","cudaMemcpy2DFromArray"],[6,3,1,"","cudaMemcpy2DFromArrayAsync"],[6,3,1,"","cudaMemcpy2DToArray"],[6,3,1,"","cudaMemcpy2DToArrayAsync"],[6,3,1,"","cudaMemcpy3D"],[6,3,1,"","cudaMemcpy3DAsync"],[6,1,1,"","cudaMemcpy3DParms"],[6,3,1,"","cudaMemcpy3DPeer"],[6,3,1,"","cudaMemcpy3DPeerAsync"],[6,1,1,"","cudaMemcpy3DPeerParms"],[6,3,1,"","cudaMemcpyAsync"],[6,1,1,"","cudaMemcpyKind"],[6,3,1,"","cudaMemcpyPeer"],[6,3,1,"","cudaMemcpyPeerAsync"],[6,1,1,"","cudaMemoryAdvise"],[6,1,1,"","cudaMemoryType"],[6,3,1,"","cudaMemset"],[6,3,1,"","cudaMemset2D"],[6,3,1,"","cudaMemset2DAsync"],[6,3,1,"","cudaMemset3D"],[6,3,1,"","cudaMemset3DAsync"],[6,3,1,"","cudaMemsetAsync"],[6,1,1,"","cudaMemsetParams"],[6,3,1,"","cudaMipmappedArrayGetMemoryRequirements"],[6,3,1,"","cudaMipmappedArrayGetSparseProperties"],[6,1,1,"","cudaMipmappedArray_const_t"],[6,1,1,"","cudaMipmappedArray_t"],[6,0,1,"","cudaNvSciSyncAttrSignal"],[6,0,1,"","cudaNvSciSyncAttrWait"],[6,3,1,"","cudaOccupancyAvailableDynamicSMemPerBlock"],[6,0,1,"","cudaOccupancyDefault"],[6,0,1,"","cudaOccupancyDisableCachingOverride"],[6,3,1,"","cudaOccupancyMaxActiveBlocksPerMultiprocessor"],[6,3,1,"","cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"],[6,1,1,"","cudaOutputMode_t"],[6,3,1,"","cudaPeekAtLastError"],[6,0,1,"","cudaPeerAccessDefault"],[6,1,1,"","cudaPitchedPtr"],[6,1,1,"","cudaPointerAttributes"],[6,3,1,"","cudaPointerGetAttributes"],[6,1,1,"","cudaPos"],[6,3,1,"","cudaProfilerStart"],[6,3,1,"","cudaProfilerStop"],[6,1,1,"","cudaResourceDesc"],[6,1,1,"","cudaResourceType"],[6,1,1,"","cudaResourceViewDesc"],[6,1,1,"","cudaResourceViewFormat"],[6,3,1,"","cudaRuntimeGetVersion"],[6,3,1,"","cudaSetDevice"],[6,3,1,"","cudaSetDeviceFlags"],[6,3,1,"","cudaSetDoubleForDevice"],[6,3,1,"","cudaSetDoubleForHost"],[6,1,1,"","cudaSharedCarveout"],[6,1,1,"","cudaSharedMemConfig"],[6,3,1,"","cudaSignalExternalSemaphoresAsync"],[6,3,1,"","cudaStreamAddCallback"],[6,3,1,"","cudaStreamAttachMemAsync"],[6,0,1,"","cudaStreamAttrID"],[6,0,1,"","cudaStreamAttrValue"],[6,3,1,"","cudaStreamBeginCapture"],[6,1,1,"","cudaStreamCallback_t"],[6,1,1,"","cudaStreamCaptureMode"],[6,1,1,"","cudaStreamCaptureStatus"],[6,3,1,"","cudaStreamCopyAttributes"],[6,3,1,"","cudaStreamCreate"],[6,3,1,"","cudaStreamCreateWithFlags"],[6,3,1,"","cudaStreamCreateWithPriority"],[6,0,1,"","cudaStreamDefault"],[6,3,1,"","cudaStreamDestroy"],[6,3,1,"","cudaStreamEndCapture"],[6,3,1,"","cudaStreamGetAttribute"],[6,3,1,"","cudaStreamGetCaptureInfo"],[6,3,1,"","cudaStreamGetCaptureInfo_v2"],[6,3,1,"","cudaStreamGetFlags"],[6,3,1,"","cudaStreamGetPriority"],[6,3,1,"","cudaStreamIsCapturing"],[6,0,1,"","cudaStreamLegacy"],[6,0,1,"","cudaStreamNonBlocking"],[6,0,1,"","cudaStreamPerThread"],[6,3,1,"","cudaStreamQuery"],[6,3,1,"","cudaStreamSetAttribute"],[6,3,1,"","cudaStreamSynchronize"],[6,3,1,"","cudaStreamUpdateCaptureDependencies"],[6,1,1,"","cudaStreamUpdateCaptureDependenciesFlags"],[6,3,1,"","cudaStreamWaitEvent"],[6,1,1,"","cudaStream_t"],[6,1,1,"","cudaSurfaceBoundaryMode"],[6,1,1,"","cudaSurfaceFormatMode"],[6,1,1,"","cudaSurfaceObject_t"],[6,0,1,"","cudaSurfaceType1D"],[6,0,1,"","cudaSurfaceType1DLayered"],[6,0,1,"","cudaSurfaceType2D"],[6,0,1,"","cudaSurfaceType2DLayered"],[6,0,1,"","cudaSurfaceType3D"],[6,0,1,"","cudaSurfaceTypeCubemap"],[6,0,1,"","cudaSurfaceTypeCubemapLayered"],[6,1,1,"","cudaSynchronizationPolicy"],[6,1,1,"","cudaTextureAddressMode"],[6,1,1,"","cudaTextureDesc"],[6,1,1,"","cudaTextureDesc_v2"],[6,1,1,"","cudaTextureFilterMode"],[6,1,1,"","cudaTextureObject_t"],[6,1,1,"","cudaTextureReadMode"],[6,0,1,"","cudaTextureType1D"],[6,0,1,"","cudaTextureType1DLayered"],[6,0,1,"","cudaTextureType2D"],[6,0,1,"","cudaTextureType2DLayered"],[6,0,1,"","cudaTextureType3D"],[6,0,1,"","cudaTextureTypeCubemap"],[6,0,1,"","cudaTextureTypeCubemapLayered"],[6,3,1,"","cudaThreadExchangeStreamCaptureMode"],[6,1,1,"","cudaUUID_t"],[6,3,1,"","cudaUserObjectCreate"],[6,1,1,"","cudaUserObjectFlags"],[6,3,1,"","cudaUserObjectRelease"],[6,3,1,"","cudaUserObjectRetain"],[6,1,1,"","cudaUserObjectRetainFlags"],[6,1,1,"","cudaUserObject_t"],[6,3,1,"","cudaVDPAUGetDevice"],[6,3,1,"","cudaVDPAUSetVDPAUDevice"],[6,3,1,"","cudaWaitExternalSemaphoresAsync"],[6,3,1,"","make_cudaExtent"],[6,3,1,"","make_cudaPitchedPtr"],[6,3,1,"","make_cudaPos"]],"cuda.cudart.CUuuid":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.CUuuid_st":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.cudaAccessPolicyWindow":[[6,0,1,"","base_ptr"],[6,2,1,"","getPtr"],[6,0,1,"","hitProp"],[6,0,1,"","hitRatio"],[6,0,1,"","missProp"],[6,0,1,"","num_bytes"]],"cuda.cudart.cudaAccessProperty":[[6,0,1,"","cudaAccessPropertyNormal"],[6,0,1,"","cudaAccessPropertyPersisting"],[6,0,1,"","cudaAccessPropertyStreaming"]],"cuda.cudart.cudaArrayMemoryRequirements":[[6,0,1,"","alignment"],[6,2,1,"","getPtr"],[6,0,1,"","reserved"],[6,0,1,"","size"]],"cuda.cudart.cudaArraySparseProperties":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","miptailFirstLevel"],[6,0,1,"","miptailSize"],[6,0,1,"","reserved"],[6,0,1,"","tileExtent"]],"cuda.cudart.cudaArray_const_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaArray_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaCGScope":[[6,0,1,"","cudaCGScopeGrid"],[6,0,1,"","cudaCGScopeInvalid"],[6,0,1,"","cudaCGScopeMultiGrid"]],"cuda.cudart.cudaChannelFormatDesc":[[6,0,1,"","f"],[6,2,1,"","getPtr"],[6,0,1,"","w"],[6,0,1,"","x"],[6,0,1,"","y"],[6,0,1,"","z"]],"cuda.cudart.cudaChannelFormatKind":[[6,0,1,"","cudaChannelFormatKindFloat"],[6,0,1,"","cudaChannelFormatKindNV12"],[6,0,1,"","cudaChannelFormatKindNone"],[6,0,1,"","cudaChannelFormatKindSigned"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed4"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed5"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed6H"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X1"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X2"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X4"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X1"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X2"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X4"],[6,0,1,"","cudaChannelFormatKindUnsigned"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed1"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed1SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed2"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed2SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed3"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed3SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed4"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed5"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed6H"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed7"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed7SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X1"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X2"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X4"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X1"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X2"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X4"]],"cuda.cudart.cudaClusterSchedulingPolicy":[[6,0,1,"","cudaClusterSchedulingPolicyDefault"],[6,0,1,"","cudaClusterSchedulingPolicyLoadBalancing"],[6,0,1,"","cudaClusterSchedulingPolicySpread"]],"cuda.cudart.cudaComputeMode":[[6,0,1,"","cudaComputeModeDefault"],[6,0,1,"","cudaComputeModeExclusive"],[6,0,1,"","cudaComputeModeExclusiveProcess"],[6,0,1,"","cudaComputeModeProhibited"]],"cuda.cudart.cudaDeviceAttr":[[6,0,1,"","cudaDevAttrAsyncEngineCount"],[6,0,1,"","cudaDevAttrCanFlushRemoteWrites"],[6,0,1,"","cudaDevAttrCanMapHostMemory"],[6,0,1,"","cudaDevAttrCanUseHostPointerForRegisteredMem"],[6,0,1,"","cudaDevAttrClockRate"],[6,0,1,"","cudaDevAttrClusterLaunch"],[6,0,1,"","cudaDevAttrComputeCapabilityMajor"],[6,0,1,"","cudaDevAttrComputeCapabilityMinor"],[6,0,1,"","cudaDevAttrComputeMode"],[6,0,1,"","cudaDevAttrComputePreemptionSupported"],[6,0,1,"","cudaDevAttrConcurrentKernels"],[6,0,1,"","cudaDevAttrConcurrentManagedAccess"],[6,0,1,"","cudaDevAttrCooperativeLaunch"],[6,0,1,"","cudaDevAttrCooperativeMultiDeviceLaunch"],[6,0,1,"","cudaDevAttrDeferredMappingCudaArraySupported"],[6,0,1,"","cudaDevAttrDirectManagedMemAccessFromHost"],[6,0,1,"","cudaDevAttrEccEnabled"],[6,0,1,"","cudaDevAttrGPUDirectRDMAFlushWritesOptions"],[6,0,1,"","cudaDevAttrGPUDirectRDMASupported"],[6,0,1,"","cudaDevAttrGPUDirectRDMAWritesOrdering"],[6,0,1,"","cudaDevAttrGlobalL1CacheSupported"],[6,0,1,"","cudaDevAttrGlobalMemoryBusWidth"],[6,0,1,"","cudaDevAttrGpuOverlap"],[6,0,1,"","cudaDevAttrHostNativeAtomicSupported"],[6,0,1,"","cudaDevAttrHostRegisterReadOnlySupported"],[6,0,1,"","cudaDevAttrHostRegisterSupported"],[6,0,1,"","cudaDevAttrIntegrated"],[6,0,1,"","cudaDevAttrIsMultiGpuBoard"],[6,0,1,"","cudaDevAttrKernelExecTimeout"],[6,0,1,"","cudaDevAttrL2CacheSize"],[6,0,1,"","cudaDevAttrLocalL1CacheSupported"],[6,0,1,"","cudaDevAttrManagedMemory"],[6,0,1,"","cudaDevAttrMax"],[6,0,1,"","cudaDevAttrMaxAccessPolicyWindowSize"],[6,0,1,"","cudaDevAttrMaxBlockDimX"],[6,0,1,"","cudaDevAttrMaxBlockDimY"],[6,0,1,"","cudaDevAttrMaxBlockDimZ"],[6,0,1,"","cudaDevAttrMaxBlocksPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxGridDimX"],[6,0,1,"","cudaDevAttrMaxGridDimY"],[6,0,1,"","cudaDevAttrMaxGridDimZ"],[6,0,1,"","cudaDevAttrMaxPersistingL2CacheSize"],[6,0,1,"","cudaDevAttrMaxPitch"],[6,0,1,"","cudaDevAttrMaxRegistersPerBlock"],[6,0,1,"","cudaDevAttrMaxRegistersPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerBlock"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerBlockOptin"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxSurface1DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurface1DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurface1DWidth"],[6,0,1,"","cudaDevAttrMaxSurface2DHeight"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredHeight"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurface2DWidth"],[6,0,1,"","cudaDevAttrMaxSurface3DDepth"],[6,0,1,"","cudaDevAttrMaxSurface3DHeight"],[6,0,1,"","cudaDevAttrMaxSurface3DWidth"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTexture1DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DLinearWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DMipmappedWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DGatherHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DGatherWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearPitch"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DMipmappedHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DMipmappedWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DWidth"],[6,0,1,"","cudaDevAttrMaxTexture3DDepth"],[6,0,1,"","cudaDevAttrMaxTexture3DDepthAlt"],[6,0,1,"","cudaDevAttrMaxTexture3DHeight"],[6,0,1,"","cudaDevAttrMaxTexture3DHeightAlt"],[6,0,1,"","cudaDevAttrMaxTexture3DWidth"],[6,0,1,"","cudaDevAttrMaxTexture3DWidthAlt"],[6,0,1,"","cudaDevAttrMaxTextureCubemapLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTextureCubemapLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTextureCubemapWidth"],[6,0,1,"","cudaDevAttrMaxThreadsPerBlock"],[6,0,1,"","cudaDevAttrMaxThreadsPerMultiProcessor"],[6,0,1,"","cudaDevAttrMaxTimelineSemaphoreInteropSupported"],[6,0,1,"","cudaDevAttrMemoryClockRate"],[6,0,1,"","cudaDevAttrMemoryPoolSupportedHandleTypes"],[6,0,1,"","cudaDevAttrMemoryPoolsSupported"],[6,0,1,"","cudaDevAttrMultiGpuBoardGroupID"],[6,0,1,"","cudaDevAttrMultiProcessorCount"],[6,0,1,"","cudaDevAttrPageableMemoryAccess"],[6,0,1,"","cudaDevAttrPageableMemoryAccessUsesHostPageTables"],[6,0,1,"","cudaDevAttrPciBusId"],[6,0,1,"","cudaDevAttrPciDeviceId"],[6,0,1,"","cudaDevAttrPciDomainId"],[6,0,1,"","cudaDevAttrReserved92"],[6,0,1,"","cudaDevAttrReserved93"],[6,0,1,"","cudaDevAttrReserved94"],[6,0,1,"","cudaDevAttrReservedSharedMemoryPerBlock"],[6,0,1,"","cudaDevAttrSingleToDoublePrecisionPerfRatio"],[6,0,1,"","cudaDevAttrSparseCudaArraySupported"],[6,0,1,"","cudaDevAttrStreamPrioritiesSupported"],[6,0,1,"","cudaDevAttrSurfaceAlignment"],[6,0,1,"","cudaDevAttrTccDriver"],[6,0,1,"","cudaDevAttrTextureAlignment"],[6,0,1,"","cudaDevAttrTexturePitchAlignment"],[6,0,1,"","cudaDevAttrTimelineSemaphoreInteropSupported"],[6,0,1,"","cudaDevAttrTotalConstantMemory"],[6,0,1,"","cudaDevAttrUnifiedAddressing"],[6,0,1,"","cudaDevAttrWarpSize"]],"cuda.cudart.cudaDeviceP2PAttr":[[6,0,1,"","cudaDevP2PAttrAccessSupported"],[6,0,1,"","cudaDevP2PAttrCudaArrayAccessSupported"],[6,0,1,"","cudaDevP2PAttrNativeAtomicSupported"],[6,0,1,"","cudaDevP2PAttrPerformanceRank"]],"cuda.cudart.cudaDeviceProp":[[6,0,1,"","ECCEnabled"],[6,0,1,"","accessPolicyMaxWindowSize"],[6,0,1,"","asyncEngineCount"],[6,0,1,"","canMapHostMemory"],[6,0,1,"","canUseHostPointerForRegisteredMem"],[6,0,1,"","clockRate"],[6,0,1,"","computeMode"],[6,0,1,"","computePreemptionSupported"],[6,0,1,"","concurrentKernels"],[6,0,1,"","concurrentManagedAccess"],[6,0,1,"","cooperativeLaunch"],[6,0,1,"","cooperativeMultiDeviceLaunch"],[6,0,1,"","deviceOverlap"],[6,0,1,"","directManagedMemAccessFromHost"],[6,2,1,"","getPtr"],[6,0,1,"","globalL1CacheSupported"],[6,0,1,"","hostNativeAtomicSupported"],[6,0,1,"","integrated"],[6,0,1,"","isMultiGpuBoard"],[6,0,1,"","kernelExecTimeoutEnabled"],[6,0,1,"","l2CacheSize"],[6,0,1,"","localL1CacheSupported"],[6,0,1,"","luid"],[6,0,1,"","luidDeviceNodeMask"],[6,0,1,"","major"],[6,0,1,"","managedMemory"],[6,0,1,"","maxBlocksPerMultiProcessor"],[6,0,1,"","maxGridSize"],[6,0,1,"","maxSurface1D"],[6,0,1,"","maxSurface1DLayered"],[6,0,1,"","maxSurface2D"],[6,0,1,"","maxSurface2DLayered"],[6,0,1,"","maxSurface3D"],[6,0,1,"","maxSurfaceCubemap"],[6,0,1,"","maxSurfaceCubemapLayered"],[6,0,1,"","maxTexture1D"],[6,0,1,"","maxTexture1DLayered"],[6,0,1,"","maxTexture1DLinear"],[6,0,1,"","maxTexture1DMipmap"],[6,0,1,"","maxTexture2D"],[6,0,1,"","maxTexture2DGather"],[6,0,1,"","maxTexture2DLayered"],[6,0,1,"","maxTexture2DLinear"],[6,0,1,"","maxTexture2DMipmap"],[6,0,1,"","maxTexture3D"],[6,0,1,"","maxTexture3DAlt"],[6,0,1,"","maxTextureCubemap"],[6,0,1,"","maxTextureCubemapLayered"],[6,0,1,"","maxThreadsDim"],[6,0,1,"","maxThreadsPerBlock"],[6,0,1,"","maxThreadsPerMultiProcessor"],[6,0,1,"","memPitch"],[6,0,1,"","memoryBusWidth"],[6,0,1,"","memoryClockRate"],[6,0,1,"","minor"],[6,0,1,"","multiGpuBoardGroupID"],[6,0,1,"","multiProcessorCount"],[6,0,1,"","name"],[6,0,1,"","pageableMemoryAccess"],[6,0,1,"","pageableMemoryAccessUsesHostPageTables"],[6,0,1,"","pciBusID"],[6,0,1,"","pciDeviceID"],[6,0,1,"","pciDomainID"],[6,0,1,"","persistingL2CacheMaxSize"],[6,0,1,"","regsPerBlock"],[6,0,1,"","regsPerMultiprocessor"],[6,0,1,"","reservedSharedMemPerBlock"],[6,0,1,"","sharedMemPerBlock"],[6,0,1,"","sharedMemPerBlockOptin"],[6,0,1,"","sharedMemPerMultiprocessor"],[6,0,1,"","singleToDoublePrecisionPerfRatio"],[6,0,1,"","streamPrioritiesSupported"],[6,0,1,"","surfaceAlignment"],[6,0,1,"","tccDriver"],[6,0,1,"","textureAlignment"],[6,0,1,"","texturePitchAlignment"],[6,0,1,"","totalConstMem"],[6,0,1,"","totalGlobalMem"],[6,0,1,"","unifiedAddressing"],[6,0,1,"","uuid"],[6,0,1,"","warpSize"]],"cuda.cudart.cudaEglColorFormat":[[6,0,1,"","cudaEglColorFormatA"],[6,0,1,"","cudaEglColorFormatABGR"],[6,0,1,"","cudaEglColorFormatARGB"],[6,0,1,"","cudaEglColorFormatAYUV"],[6,0,1,"","cudaEglColorFormatAYUV_ER"],[6,0,1,"","cudaEglColorFormatBGRA"],[6,0,1,"","cudaEglColorFormatBayer10BGGR"],[6,0,1,"","cudaEglColorFormatBayer10CCCC"],[6,0,1,"","cudaEglColorFormatBayer10GBRG"],[6,0,1,"","cudaEglColorFormatBayer10GRBG"],[6,0,1,"","cudaEglColorFormatBayer10RGGB"],[6,0,1,"","cudaEglColorFormatBayer12BCCR"],[6,0,1,"","cudaEglColorFormatBayer12BGGR"],[6,0,1,"","cudaEglColorFormatBayer12CBRC"],[6,0,1,"","cudaEglColorFormatBayer12CCCC"],[6,0,1,"","cudaEglColorFormatBayer12CRBC"],[6,0,1,"","cudaEglColorFormatBayer12GBRG"],[6,0,1,"","cudaEglColorFormatBayer12GRBG"],[6,0,1,"","cudaEglColorFormatBayer12RCCB"],[6,0,1,"","cudaEglColorFormatBayer12RGGB"],[6,0,1,"","cudaEglColorFormatBayer14BGGR"],[6,0,1,"","cudaEglColorFormatBayer14GBRG"],[6,0,1,"","cudaEglColorFormatBayer14GRBG"],[6,0,1,"","cudaEglColorFormatBayer14RGGB"],[6,0,1,"","cudaEglColorFormatBayer20BGGR"],[6,0,1,"","cudaEglColorFormatBayer20GBRG"],[6,0,1,"","cudaEglColorFormatBayer20GRBG"],[6,0,1,"","cudaEglColorFormatBayer20RGGB"],[6,0,1,"","cudaEglColorFormatBayerBCCR"],[6,0,1,"","cudaEglColorFormatBayerBGGR"],[6,0,1,"","cudaEglColorFormatBayerCBRC"],[6,0,1,"","cudaEglColorFormatBayerCRBC"],[6,0,1,"","cudaEglColorFormatBayerGBRG"],[6,0,1,"","cudaEglColorFormatBayerGRBG"],[6,0,1,"","cudaEglColorFormatBayerIspBGGR"],[6,0,1,"","cudaEglColorFormatBayerIspGBRG"],[6,0,1,"","cudaEglColorFormatBayerIspGRBG"],[6,0,1,"","cudaEglColorFormatBayerIspRGGB"],[6,0,1,"","cudaEglColorFormatBayerRCCB"],[6,0,1,"","cudaEglColorFormatBayerRGGB"],[6,0,1,"","cudaEglColorFormatL"],[6,0,1,"","cudaEglColorFormatR"],[6,0,1,"","cudaEglColorFormatRG"],[6,0,1,"","cudaEglColorFormatRGBA"],[6,0,1,"","cudaEglColorFormatUYVY422"],[6,0,1,"","cudaEglColorFormatUYVY_ER"],[6,0,1,"","cudaEglColorFormatVYUY"],[6,0,1,"","cudaEglColorFormatVYUY_ER"],[6,0,1,"","cudaEglColorFormatY"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY10_709_ER"],[6,0,1,"","cudaEglColorFormatY10_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY12_709_ER"],[6,0,1,"","cudaEglColorFormatY12_ER"],[6,0,1,"","cudaEglColorFormatYUV420Planar"],[6,0,1,"","cudaEglColorFormatYUV420Planar_2020"],[6,0,1,"","cudaEglColorFormatYUV420Planar_709"],[6,0,1,"","cudaEglColorFormatYUV420Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUV422Planar"],[6,0,1,"","cudaEglColorFormatYUV422Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV422SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV422SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUV444Planar"],[6,0,1,"","cudaEglColorFormatYUV444Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV444SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUVA"],[6,0,1,"","cudaEglColorFormatYUVA_ER"],[6,0,1,"","cudaEglColorFormatYUYV422"],[6,0,1,"","cudaEglColorFormatYUYV_ER"],[6,0,1,"","cudaEglColorFormatYVU420Planar"],[6,0,1,"","cudaEglColorFormatYVU420Planar_2020"],[6,0,1,"","cudaEglColorFormatYVU420Planar_709"],[6,0,1,"","cudaEglColorFormatYVU420Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVU422Planar"],[6,0,1,"","cudaEglColorFormatYVU422Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU422SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU422SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVU444Planar"],[6,0,1,"","cudaEglColorFormatYVU444Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU444SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVYU"],[6,0,1,"","cudaEglColorFormatYVYU_ER"],[6,0,1,"","cudaEglColorFormatY_709_ER"],[6,0,1,"","cudaEglColorFormatY_ER"]],"cuda.cudart.cudaEglFrame":[[6,0,1,"","eglColorFormat"],[6,0,1,"","frame"],[6,0,1,"","frameType"],[6,2,1,"","getPtr"],[6,0,1,"","planeCount"],[6,0,1,"","planeDesc"]],"cuda.cudart.cudaEglFrameType":[[6,0,1,"","cudaEglFrameTypeArray"],[6,0,1,"","cudaEglFrameTypePitch"]],"cuda.cudart.cudaEglFrame_st":[[6,0,1,"","eglColorFormat"],[6,0,1,"","frame"],[6,0,1,"","frameType"],[6,2,1,"","getPtr"],[6,0,1,"","planeCount"],[6,0,1,"","planeDesc"]],"cuda.cudart.cudaEglPlaneDesc":[[6,0,1,"","channelDesc"],[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","numChannels"],[6,0,1,"","pitch"],[6,0,1,"","reserved"],[6,0,1,"","width"]],"cuda.cudart.cudaEglPlaneDesc_st":[[6,0,1,"","channelDesc"],[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","numChannels"],[6,0,1,"","pitch"],[6,0,1,"","reserved"],[6,0,1,"","width"]],"cuda.cudart.cudaEglResourceLocationFlags":[[6,0,1,"","cudaEglResourceLocationSysmem"],[6,0,1,"","cudaEglResourceLocationVidmem"]],"cuda.cudart.cudaEglStreamConnection":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaError_t":[[6,0,1,"","cudaErrorAddressOfConstant"],[6,0,1,"","cudaErrorAlreadyAcquired"],[6,0,1,"","cudaErrorAlreadyMapped"],[6,0,1,"","cudaErrorApiFailureBase"],[6,0,1,"","cudaErrorArrayIsMapped"],[6,0,1,"","cudaErrorAssert"],[6,0,1,"","cudaErrorCallRequiresNewerDriver"],[6,0,1,"","cudaErrorCapturedEvent"],[6,0,1,"","cudaErrorCompatNotSupportedOnDevice"],[6,0,1,"","cudaErrorContextIsDestroyed"],[6,0,1,"","cudaErrorCooperativeLaunchTooLarge"],[6,0,1,"","cudaErrorCudartUnloading"],[6,0,1,"","cudaErrorDeviceAlreadyInUse"],[6,0,1,"","cudaErrorDeviceNotLicensed"],[6,0,1,"","cudaErrorDeviceUninitialized"],[6,0,1,"","cudaErrorDevicesUnavailable"],[6,0,1,"","cudaErrorDuplicateSurfaceName"],[6,0,1,"","cudaErrorDuplicateTextureName"],[6,0,1,"","cudaErrorDuplicateVariableName"],[6,0,1,"","cudaErrorECCUncorrectable"],[6,0,1,"","cudaErrorExternalDevice"],[6,0,1,"","cudaErrorFileNotFound"],[6,0,1,"","cudaErrorGraphExecUpdateFailure"],[6,0,1,"","cudaErrorHardwareStackError"],[6,0,1,"","cudaErrorHostMemoryAlreadyRegistered"],[6,0,1,"","cudaErrorHostMemoryNotRegistered"],[6,0,1,"","cudaErrorIllegalAddress"],[6,0,1,"","cudaErrorIllegalInstruction"],[6,0,1,"","cudaErrorIllegalState"],[6,0,1,"","cudaErrorIncompatibleDriverContext"],[6,0,1,"","cudaErrorInitializationError"],[6,0,1,"","cudaErrorInsufficientDriver"],[6,0,1,"","cudaErrorInvalidAddressSpace"],[6,0,1,"","cudaErrorInvalidChannelDescriptor"],[6,0,1,"","cudaErrorInvalidClusterSize"],[6,0,1,"","cudaErrorInvalidConfiguration"],[6,0,1,"","cudaErrorInvalidDevice"],[6,0,1,"","cudaErrorInvalidDeviceFunction"],[6,0,1,"","cudaErrorInvalidDevicePointer"],[6,0,1,"","cudaErrorInvalidFilterSetting"],[6,0,1,"","cudaErrorInvalidGraphicsContext"],[6,0,1,"","cudaErrorInvalidHostPointer"],[6,0,1,"","cudaErrorInvalidKernelImage"],[6,0,1,"","cudaErrorInvalidMemcpyDirection"],[6,0,1,"","cudaErrorInvalidNormSetting"],[6,0,1,"","cudaErrorInvalidPc"],[6,0,1,"","cudaErrorInvalidPitchValue"],[6,0,1,"","cudaErrorInvalidPtx"],[6,0,1,"","cudaErrorInvalidResourceHandle"],[6,0,1,"","cudaErrorInvalidSource"],[6,0,1,"","cudaErrorInvalidSurface"],[6,0,1,"","cudaErrorInvalidSymbol"],[6,0,1,"","cudaErrorInvalidTexture"],[6,0,1,"","cudaErrorInvalidTextureBinding"],[6,0,1,"","cudaErrorInvalidValue"],[6,0,1,"","cudaErrorJitCompilationDisabled"],[6,0,1,"","cudaErrorJitCompilerNotFound"],[6,0,1,"","cudaErrorLaunchFailure"],[6,0,1,"","cudaErrorLaunchFileScopedSurf"],[6,0,1,"","cudaErrorLaunchFileScopedTex"],[6,0,1,"","cudaErrorLaunchIncompatibleTexturing"],[6,0,1,"","cudaErrorLaunchMaxDepthExceeded"],[6,0,1,"","cudaErrorLaunchOutOfResources"],[6,0,1,"","cudaErrorLaunchPendingCountExceeded"],[6,0,1,"","cudaErrorLaunchTimeout"],[6,0,1,"","cudaErrorMapBufferObjectFailed"],[6,0,1,"","cudaErrorMemoryAllocation"],[6,0,1,"","cudaErrorMemoryValueTooLarge"],[6,0,1,"","cudaErrorMisalignedAddress"],[6,0,1,"","cudaErrorMissingConfiguration"],[6,0,1,"","cudaErrorMixedDeviceExecution"],[6,0,1,"","cudaErrorMpsClientTerminated"],[6,0,1,"","cudaErrorMpsConnectionFailed"],[6,0,1,"","cudaErrorMpsMaxClientsReached"],[6,0,1,"","cudaErrorMpsMaxConnectionsReached"],[6,0,1,"","cudaErrorMpsRpcFailure"],[6,0,1,"","cudaErrorMpsServerNotReady"],[6,0,1,"","cudaErrorNoDevice"],[6,0,1,"","cudaErrorNoKernelImageForDevice"],[6,0,1,"","cudaErrorNotMapped"],[6,0,1,"","cudaErrorNotMappedAsArray"],[6,0,1,"","cudaErrorNotMappedAsPointer"],[6,0,1,"","cudaErrorNotPermitted"],[6,0,1,"","cudaErrorNotReady"],[6,0,1,"","cudaErrorNotSupported"],[6,0,1,"","cudaErrorNotYetImplemented"],[6,0,1,"","cudaErrorNvlinkUncorrectable"],[6,0,1,"","cudaErrorOperatingSystem"],[6,0,1,"","cudaErrorPeerAccessAlreadyEnabled"],[6,0,1,"","cudaErrorPeerAccessNotEnabled"],[6,0,1,"","cudaErrorPeerAccessUnsupported"],[6,0,1,"","cudaErrorPriorLaunchFailure"],[6,0,1,"","cudaErrorProfilerAlreadyStarted"],[6,0,1,"","cudaErrorProfilerAlreadyStopped"],[6,0,1,"","cudaErrorProfilerDisabled"],[6,0,1,"","cudaErrorProfilerNotInitialized"],[6,0,1,"","cudaErrorSetOnActiveProcess"],[6,0,1,"","cudaErrorSharedObjectInitFailed"],[6,0,1,"","cudaErrorSharedObjectSymbolNotFound"],[6,0,1,"","cudaErrorSoftwareValidityNotEstablished"],[6,0,1,"","cudaErrorStartupFailure"],[6,0,1,"","cudaErrorStreamCaptureImplicit"],[6,0,1,"","cudaErrorStreamCaptureInvalidated"],[6,0,1,"","cudaErrorStreamCaptureIsolation"],[6,0,1,"","cudaErrorStreamCaptureMerge"],[6,0,1,"","cudaErrorStreamCaptureUnjoined"],[6,0,1,"","cudaErrorStreamCaptureUnmatched"],[6,0,1,"","cudaErrorStreamCaptureUnsupported"],[6,0,1,"","cudaErrorStreamCaptureWrongThread"],[6,0,1,"","cudaErrorStubLibrary"],[6,0,1,"","cudaErrorSymbolNotFound"],[6,0,1,"","cudaErrorSyncDepthExceeded"],[6,0,1,"","cudaErrorSynchronizationError"],[6,0,1,"","cudaErrorSystemDriverMismatch"],[6,0,1,"","cudaErrorSystemNotReady"],[6,0,1,"","cudaErrorTextureFetchFailed"],[6,0,1,"","cudaErrorTextureNotBound"],[6,0,1,"","cudaErrorTimeout"],[6,0,1,"","cudaErrorTooManyPeers"],[6,0,1,"","cudaErrorUnknown"],[6,0,1,"","cudaErrorUnmapBufferObjectFailed"],[6,0,1,"","cudaErrorUnsupportedExecAffinity"],[6,0,1,"","cudaErrorUnsupportedLimit"],[6,0,1,"","cudaErrorUnsupportedPtxVersion"],[6,0,1,"","cudaSuccess"]],"cuda.cudart.cudaEvent_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaExtent":[[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","width"]],"cuda.cudart.cudaExternalMemoryBufferDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","offset"],[6,0,1,"","size"]],"cuda.cudart.cudaExternalMemoryHandleDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","handle"],[6,0,1,"","size"],[6,0,1,"","type"]],"cuda.cudart.cudaExternalMemoryHandleType":[[6,0,1,"","cudaExternalMemoryHandleTypeD3D11Resource"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D11ResourceKmt"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D12Heap"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D12Resource"],[6,0,1,"","cudaExternalMemoryHandleTypeNvSciBuf"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueFd"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueWin32"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueWin32Kmt"]],"cuda.cudart.cudaExternalMemoryMipmappedArrayDesc":[[6,0,1,"","extent"],[6,0,1,"","flags"],[6,0,1,"","formatDesc"],[6,2,1,"","getPtr"],[6,0,1,"","numLevels"],[6,0,1,"","offset"]],"cuda.cudart.cudaExternalMemory_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaExternalSemaphoreHandleDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","handle"],[6,0,1,"","type"]],"cuda.cudart.cudaExternalSemaphoreHandleType":[[6,0,1,"","cudaExternalSemaphoreHandleTypeD3D11Fence"],[6,0,1,"","cudaExternalSemaphoreHandleTypeD3D12Fence"],[6,0,1,"","cudaExternalSemaphoreHandleTypeKeyedMutex"],[6,0,1,"","cudaExternalSemaphoreHandleTypeKeyedMutexKmt"],[6,0,1,"","cudaExternalSemaphoreHandleTypeNvSciSync"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueFd"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueWin32"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt"],[6,0,1,"","cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd"],[6,0,1,"","cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32"]],"cuda.cudart.cudaExternalSemaphoreSignalNodeParams":[[6,0,1,"","extSemArray"],[6,2,1,"","getPtr"],[6,0,1,"","numExtSems"],[6,0,1,"","paramsArray"]],"cuda.cudart.cudaExternalSemaphoreSignalParams":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","params"],[6,0,1,"","reserved"]],"cuda.cudart.cudaExternalSemaphoreWaitNodeParams":[[6,0,1,"","extSemArray"],[6,2,1,"","getPtr"],[6,0,1,"","numExtSems"],[6,0,1,"","paramsArray"]],"cuda.cudart.cudaExternalSemaphoreWaitParams":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","params"],[6,0,1,"","reserved"]],"cuda.cudart.cudaExternalSemaphore_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesOptions":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesOptionHost"],[6,0,1,"","cudaFlushGPUDirectRDMAWritesOptionMemOps"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesScope":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesToAllDevices"],[6,0,1,"","cudaFlushGPUDirectRDMAWritesToOwner"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesTarget":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesTargetCurrentDevice"]],"cuda.cudart.cudaFuncAttribute":[[6,0,1,"","cudaFuncAttributeClusterDimMustBeSet"],[6,0,1,"","cudaFuncAttributeClusterSchedulingPolicyPreference"],[6,0,1,"","cudaFuncAttributeMax"],[6,0,1,"","cudaFuncAttributeMaxDynamicSharedMemorySize"],[6,0,1,"","cudaFuncAttributeNonPortableClusterSizeAllowed"],[6,0,1,"","cudaFuncAttributePreferredSharedMemoryCarveout"],[6,0,1,"","cudaFuncAttributeRequiredClusterDepth"],[6,0,1,"","cudaFuncAttributeRequiredClusterHeight"],[6,0,1,"","cudaFuncAttributeRequiredClusterWidth"]],"cuda.cudart.cudaFuncAttributes":[[6,0,1,"","binaryVersion"],[6,0,1,"","cacheModeCA"],[6,0,1,"","constSizeBytes"],[6,2,1,"","getPtr"],[6,0,1,"","localSizeBytes"],[6,0,1,"","maxDynamicSharedSizeBytes"],[6,0,1,"","maxThreadsPerBlock"],[6,0,1,"","numRegs"],[6,0,1,"","preferredShmemCarveout"],[6,0,1,"","ptxVersion"],[6,0,1,"","sharedSizeBytes"]],"cuda.cudart.cudaFuncCache":[[6,0,1,"","cudaFuncCachePreferEqual"],[6,0,1,"","cudaFuncCachePreferL1"],[6,0,1,"","cudaFuncCachePreferNone"],[6,0,1,"","cudaFuncCachePreferShared"]],"cuda.cudart.cudaFunction_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGLDeviceList":[[6,0,1,"","cudaGLDeviceListAll"],[6,0,1,"","cudaGLDeviceListCurrentFrame"],[6,0,1,"","cudaGLDeviceListNextFrame"]],"cuda.cudart.cudaGPUDirectRDMAWritesOrdering":[[6,0,1,"","cudaGPUDirectRDMAWritesOrderingAllDevices"],[6,0,1,"","cudaGPUDirectRDMAWritesOrderingNone"],[6,0,1,"","cudaGPUDirectRDMAWritesOrderingOwner"]],"cuda.cudart.cudaGetDriverEntryPointFlags":[[6,0,1,"","cudaEnableDefault"],[6,0,1,"","cudaEnableLegacyStream"],[6,0,1,"","cudaEnablePerThreadDefaultStream"]],"cuda.cudart.cudaGraphDebugDotFlags":[[6,0,1,"","cudaGraphDebugDotFlagsEventNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsExtSemasSignalNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsExtSemasWaitNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsHandles"],[6,0,1,"","cudaGraphDebugDotFlagsHostNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsKernelNodeAttributes"],[6,0,1,"","cudaGraphDebugDotFlagsKernelNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsMemcpyNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsMemsetNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsVerbose"]],"cuda.cudart.cudaGraphExecUpdateResult":[[6,0,1,"","cudaGraphExecUpdateError"],[6,0,1,"","cudaGraphExecUpdateErrorAttributesChanged"],[6,0,1,"","cudaGraphExecUpdateErrorFunctionChanged"],[6,0,1,"","cudaGraphExecUpdateErrorNodeTypeChanged"],[6,0,1,"","cudaGraphExecUpdateErrorNotSupported"],[6,0,1,"","cudaGraphExecUpdateErrorParametersChanged"],[6,0,1,"","cudaGraphExecUpdateErrorTopologyChanged"],[6,0,1,"","cudaGraphExecUpdateErrorUnsupportedFunctionChange"],[6,0,1,"","cudaGraphExecUpdateSuccess"]],"cuda.cudart.cudaGraphExec_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraphInstantiateFlags":[[6,0,1,"","cudaGraphInstantiateFlagAutoFreeOnLaunch"],[6,0,1,"","cudaGraphInstantiateFlagUseNodePriority"]],"cuda.cudart.cudaGraphMemAttributeType":[[6,0,1,"","cudaGraphMemAttrReservedMemCurrent"],[6,0,1,"","cudaGraphMemAttrReservedMemHigh"],[6,0,1,"","cudaGraphMemAttrUsedMemCurrent"],[6,0,1,"","cudaGraphMemAttrUsedMemHigh"]],"cuda.cudart.cudaGraphNodeType":[[6,0,1,"","cudaGraphNodeTypeCount"],[6,0,1,"","cudaGraphNodeTypeEmpty"],[6,0,1,"","cudaGraphNodeTypeEventRecord"],[6,0,1,"","cudaGraphNodeTypeExtSemaphoreSignal"],[6,0,1,"","cudaGraphNodeTypeExtSemaphoreWait"],[6,0,1,"","cudaGraphNodeTypeGraph"],[6,0,1,"","cudaGraphNodeTypeHost"],[6,0,1,"","cudaGraphNodeTypeKernel"],[6,0,1,"","cudaGraphNodeTypeMemAlloc"],[6,0,1,"","cudaGraphNodeTypeMemFree"],[6,0,1,"","cudaGraphNodeTypeMemcpy"],[6,0,1,"","cudaGraphNodeTypeMemset"],[6,0,1,"","cudaGraphNodeTypeWaitEvent"]],"cuda.cudart.cudaGraphNode_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraph_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraphicsCubeFace":[[6,0,1,"","cudaGraphicsCubeFaceNegativeX"],[6,0,1,"","cudaGraphicsCubeFaceNegativeY"],[6,0,1,"","cudaGraphicsCubeFaceNegativeZ"],[6,0,1,"","cudaGraphicsCubeFacePositiveX"],[6,0,1,"","cudaGraphicsCubeFacePositiveY"],[6,0,1,"","cudaGraphicsCubeFacePositiveZ"]],"cuda.cudart.cudaGraphicsMapFlags":[[6,0,1,"","cudaGraphicsMapFlagsNone"],[6,0,1,"","cudaGraphicsMapFlagsReadOnly"],[6,0,1,"","cudaGraphicsMapFlagsWriteDiscard"]],"cuda.cudart.cudaGraphicsRegisterFlags":[[6,0,1,"","cudaGraphicsRegisterFlagsNone"],[6,0,1,"","cudaGraphicsRegisterFlagsReadOnly"],[6,0,1,"","cudaGraphicsRegisterFlagsSurfaceLoadStore"],[6,0,1,"","cudaGraphicsRegisterFlagsTextureGather"],[6,0,1,"","cudaGraphicsRegisterFlagsWriteDiscard"]],"cuda.cudart.cudaGraphicsResource_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaHostFn_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaHostNodeParams":[[6,0,1,"","fn"],[6,2,1,"","getPtr"],[6,0,1,"","userData"]],"cuda.cudart.cudaIpcEventHandle_st":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcEventHandle_t":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcMemHandle_st":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcMemHandle_t":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaKernelNodeParams":[[6,0,1,"","blockDim"],[6,0,1,"","extra"],[6,0,1,"","func"],[6,2,1,"","getPtr"],[6,0,1,"","gridDim"],[6,0,1,"","kernelParams"],[6,0,1,"","sharedMemBytes"]],"cuda.cudart.cudaLaunchAttribute":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","val"]],"cuda.cudart.cudaLaunchAttributeID":[[6,0,1,"","cudaLaunchAttributeAccessPolicyWindow"],[6,0,1,"","cudaLaunchAttributeClusterDimension"],[6,0,1,"","cudaLaunchAttributeClusterSchedulingPolicyPreference"],[6,0,1,"","cudaLaunchAttributeCooperative"],[6,0,1,"","cudaLaunchAttributeIgnore"],[6,0,1,"","cudaLaunchAttributePriority"],[6,0,1,"","cudaLaunchAttributeProgrammaticEvent"],[6,0,1,"","cudaLaunchAttributeProgrammaticStreamSerialization"],[6,0,1,"","cudaLaunchAttributeSynchronizationPolicy"]],"cuda.cudart.cudaLaunchAttributeValue":[[6,0,1,"id28","accessPolicyWindow"],[6,0,1,"id31","clusterDim"],[6,0,1,"id32","clusterSchedulingPolicyPreference"],[6,0,1,"id29","cooperative"],[6,2,1,"id36","getPtr"],[6,0,1,"id27","pad"],[6,0,1,"id35","priority"],[6,0,1,"id34","programmaticEvent"],[6,0,1,"id33","programmaticStreamSerializationAllowed"],[6,0,1,"id30","syncPolicy"]],"cuda.cudart.cudaLaunchAttribute_st":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","val"]],"cuda.cudart.cudaLimit":[[6,0,1,"","cudaLimitDevRuntimePendingLaunchCount"],[6,0,1,"","cudaLimitDevRuntimeSyncDepth"],[6,0,1,"","cudaLimitMallocHeapSize"],[6,0,1,"","cudaLimitMaxL2FetchGranularity"],[6,0,1,"","cudaLimitPersistingL2CacheSize"],[6,0,1,"","cudaLimitPrintfFifoSize"],[6,0,1,"","cudaLimitStackSize"]],"cuda.cudart.cudaMemAccessDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","location"]],"cuda.cudart.cudaMemAccessFlags":[[6,0,1,"","cudaMemAccessFlagsProtNone"],[6,0,1,"","cudaMemAccessFlagsProtRead"],[6,0,1,"","cudaMemAccessFlagsProtReadWrite"]],"cuda.cudart.cudaMemAllocNodeParams":[[6,0,1,"","accessDescCount"],[6,0,1,"","accessDescs"],[6,0,1,"","bytesize"],[6,0,1,"","dptr"],[6,2,1,"","getPtr"],[6,0,1,"","poolProps"]],"cuda.cudart.cudaMemAllocationHandleType":[[6,0,1,"","cudaMemHandleTypeNone"],[6,0,1,"","cudaMemHandleTypePosixFileDescriptor"],[6,0,1,"","cudaMemHandleTypeWin32"],[6,0,1,"","cudaMemHandleTypeWin32Kmt"]],"cuda.cudart.cudaMemAllocationType":[[6,0,1,"","cudaMemAllocationTypeInvalid"],[6,0,1,"","cudaMemAllocationTypeMax"],[6,0,1,"","cudaMemAllocationTypePinned"]],"cuda.cudart.cudaMemLocation":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","type"]],"cuda.cudart.cudaMemLocationType":[[6,0,1,"","cudaMemLocationTypeDevice"],[6,0,1,"","cudaMemLocationTypeInvalid"]],"cuda.cudart.cudaMemPoolAttr":[[6,0,1,"","cudaMemPoolAttrReleaseThreshold"],[6,0,1,"","cudaMemPoolAttrReservedMemCurrent"],[6,0,1,"","cudaMemPoolAttrReservedMemHigh"],[6,0,1,"","cudaMemPoolAttrUsedMemCurrent"],[6,0,1,"","cudaMemPoolAttrUsedMemHigh"],[6,0,1,"","cudaMemPoolReuseAllowInternalDependencies"],[6,0,1,"","cudaMemPoolReuseAllowOpportunistic"],[6,0,1,"","cudaMemPoolReuseFollowEventDependencies"]],"cuda.cudart.cudaMemPoolProps":[[6,0,1,"","allocType"],[6,2,1,"","getPtr"],[6,0,1,"","handleTypes"],[6,0,1,"","location"],[6,0,1,"","reserved"],[6,0,1,"","win32SecurityAttributes"]],"cuda.cudart.cudaMemPoolPtrExportData":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaMemPool_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaMemRangeAttribute":[[6,0,1,"","cudaMemRangeAttributeAccessedBy"],[6,0,1,"","cudaMemRangeAttributeLastPrefetchLocation"],[6,0,1,"","cudaMemRangeAttributePreferredLocation"],[6,0,1,"","cudaMemRangeAttributeReadMostly"]],"cuda.cudart.cudaMemcpy3DParms":[[6,0,1,"","dstArray"],[6,0,1,"","dstPos"],[6,0,1,"","dstPtr"],[6,0,1,"","extent"],[6,2,1,"","getPtr"],[6,0,1,"","kind"],[6,0,1,"","srcArray"],[6,0,1,"","srcPos"],[6,0,1,"","srcPtr"]],"cuda.cudart.cudaMemcpy3DPeerParms":[[6,0,1,"","dstArray"],[6,0,1,"","dstDevice"],[6,0,1,"","dstPos"],[6,0,1,"","dstPtr"],[6,0,1,"","extent"],[6,2,1,"","getPtr"],[6,0,1,"","srcArray"],[6,0,1,"","srcDevice"],[6,0,1,"","srcPos"],[6,0,1,"","srcPtr"]],"cuda.cudart.cudaMemcpyKind":[[6,0,1,"","cudaMemcpyDefault"],[6,0,1,"","cudaMemcpyDeviceToDevice"],[6,0,1,"","cudaMemcpyDeviceToHost"],[6,0,1,"","cudaMemcpyHostToDevice"],[6,0,1,"","cudaMemcpyHostToHost"]],"cuda.cudart.cudaMemoryAdvise":[[6,0,1,"","cudaMemAdviseSetAccessedBy"],[6,0,1,"","cudaMemAdviseSetPreferredLocation"],[6,0,1,"","cudaMemAdviseSetReadMostly"],[6,0,1,"","cudaMemAdviseUnsetAccessedBy"],[6,0,1,"","cudaMemAdviseUnsetPreferredLocation"],[6,0,1,"","cudaMemAdviseUnsetReadMostly"]],"cuda.cudart.cudaMemoryType":[[6,0,1,"","cudaMemoryTypeDevice"],[6,0,1,"","cudaMemoryTypeHost"],[6,0,1,"","cudaMemoryTypeManaged"],[6,0,1,"","cudaMemoryTypeUnregistered"]],"cuda.cudart.cudaMemsetParams":[[6,0,1,"","dst"],[6,0,1,"","elementSize"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","pitch"],[6,0,1,"","value"],[6,0,1,"","width"]],"cuda.cudart.cudaMipmappedArray_const_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaMipmappedArray_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaOutputMode_t":[[6,0,1,"","cudaCSV"],[6,0,1,"","cudaKeyValuePair"]],"cuda.cudart.cudaPitchedPtr":[[6,2,1,"","getPtr"],[6,0,1,"","pitch"],[6,0,1,"","ptr"],[6,0,1,"","xsize"],[6,0,1,"","ysize"]],"cuda.cudart.cudaPointerAttributes":[[6,0,1,"","device"],[6,0,1,"","devicePointer"],[6,2,1,"","getPtr"],[6,0,1,"","hostPointer"],[6,0,1,"","type"]],"cuda.cudart.cudaPos":[[6,2,1,"","getPtr"],[6,0,1,"","x"],[6,0,1,"","y"],[6,0,1,"","z"]],"cuda.cudart.cudaResourceDesc":[[6,2,1,"","getPtr"],[6,0,1,"","res"],[6,0,1,"","resType"]],"cuda.cudart.cudaResourceType":[[6,0,1,"","cudaResourceTypeArray"],[6,0,1,"","cudaResourceTypeLinear"],[6,0,1,"","cudaResourceTypeMipmappedArray"],[6,0,1,"","cudaResourceTypePitch2D"]],"cuda.cudart.cudaResourceViewDesc":[[6,0,1,"","depth"],[6,0,1,"","firstLayer"],[6,0,1,"","firstMipmapLevel"],[6,0,1,"","format"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","lastLayer"],[6,0,1,"","lastMipmapLevel"],[6,0,1,"","width"]],"cuda.cudart.cudaResourceViewFormat":[[6,0,1,"","cudaResViewFormatFloat1"],[6,0,1,"","cudaResViewFormatFloat2"],[6,0,1,"","cudaResViewFormatFloat4"],[6,0,1,"","cudaResViewFormatHalf1"],[6,0,1,"","cudaResViewFormatHalf2"],[6,0,1,"","cudaResViewFormatHalf4"],[6,0,1,"","cudaResViewFormatNone"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed4"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed5"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed6H"],[6,0,1,"","cudaResViewFormatSignedChar1"],[6,0,1,"","cudaResViewFormatSignedChar2"],[6,0,1,"","cudaResViewFormatSignedChar4"],[6,0,1,"","cudaResViewFormatSignedInt1"],[6,0,1,"","cudaResViewFormatSignedInt2"],[6,0,1,"","cudaResViewFormatSignedInt4"],[6,0,1,"","cudaResViewFormatSignedShort1"],[6,0,1,"","cudaResViewFormatSignedShort2"],[6,0,1,"","cudaResViewFormatSignedShort4"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed1"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed2"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed3"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed4"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed5"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed6H"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed7"],[6,0,1,"","cudaResViewFormatUnsignedChar1"],[6,0,1,"","cudaResViewFormatUnsignedChar2"],[6,0,1,"","cudaResViewFormatUnsignedChar4"],[6,0,1,"","cudaResViewFormatUnsignedInt1"],[6,0,1,"","cudaResViewFormatUnsignedInt2"],[6,0,1,"","cudaResViewFormatUnsignedInt4"],[6,0,1,"","cudaResViewFormatUnsignedShort1"],[6,0,1,"","cudaResViewFormatUnsignedShort2"],[6,0,1,"","cudaResViewFormatUnsignedShort4"]],"cuda.cudart.cudaSharedCarveout":[[6,0,1,"","cudaSharedmemCarveoutDefault"],[6,0,1,"","cudaSharedmemCarveoutMaxL1"],[6,0,1,"","cudaSharedmemCarveoutMaxShared"]],"cuda.cudart.cudaSharedMemConfig":[[6,0,1,"","cudaSharedMemBankSizeDefault"],[6,0,1,"","cudaSharedMemBankSizeEightByte"],[6,0,1,"","cudaSharedMemBankSizeFourByte"]],"cuda.cudart.cudaStreamCallback_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaStreamCaptureMode":[[6,0,1,"","cudaStreamCaptureModeGlobal"],[6,0,1,"","cudaStreamCaptureModeRelaxed"],[6,0,1,"","cudaStreamCaptureModeThreadLocal"]],"cuda.cudart.cudaStreamCaptureStatus":[[6,0,1,"","cudaStreamCaptureStatusActive"],[6,0,1,"","cudaStreamCaptureStatusInvalidated"],[6,0,1,"","cudaStreamCaptureStatusNone"]],"cuda.cudart.cudaStreamUpdateCaptureDependenciesFlags":[[6,0,1,"","cudaStreamAddCaptureDependencies"],[6,0,1,"","cudaStreamSetCaptureDependencies"]],"cuda.cudart.cudaStream_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaSurfaceBoundaryMode":[[6,0,1,"","cudaBoundaryModeClamp"],[6,0,1,"","cudaBoundaryModeTrap"],[6,0,1,"","cudaBoundaryModeZero"]],"cuda.cudart.cudaSurfaceFormatMode":[[6,0,1,"","cudaFormatModeAuto"],[6,0,1,"","cudaFormatModeForced"]],"cuda.cudart.cudaSurfaceObject_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaSynchronizationPolicy":[[6,0,1,"","cudaSyncPolicyAuto"],[6,0,1,"","cudaSyncPolicyBlockingSync"],[6,0,1,"","cudaSyncPolicySpin"],[6,0,1,"","cudaSyncPolicyYield"]],"cuda.cudart.cudaTextureAddressMode":[[6,0,1,"","cudaAddressModeBorder"],[6,0,1,"","cudaAddressModeClamp"],[6,0,1,"","cudaAddressModeMirror"],[6,0,1,"","cudaAddressModeWrap"]],"cuda.cudart.cudaTextureDesc":[[6,0,1,"","addressMode"],[6,0,1,"","borderColor"],[6,0,1,"","disableTrilinearOptimization"],[6,0,1,"","filterMode"],[6,2,1,"","getPtr"],[6,0,1,"","maxAnisotropy"],[6,0,1,"","maxMipmapLevelClamp"],[6,0,1,"","minMipmapLevelClamp"],[6,0,1,"","mipmapFilterMode"],[6,0,1,"","mipmapLevelBias"],[6,0,1,"","normalizedCoords"],[6,0,1,"","readMode"],[6,0,1,"","sRGB"]],"cuda.cudart.cudaTextureDesc_v2":[[6,0,1,"","addressMode"],[6,0,1,"","borderColor"],[6,0,1,"","disableTrilinearOptimization"],[6,0,1,"","filterMode"],[6,2,1,"","getPtr"],[6,0,1,"","maxAnisotropy"],[6,0,1,"","maxMipmapLevelClamp"],[6,0,1,"","minMipmapLevelClamp"],[6,0,1,"","mipmapFilterMode"],[6,0,1,"","mipmapLevelBias"],[6,0,1,"","normalizedCoords"],[6,0,1,"","readMode"],[6,0,1,"","sRGB"],[6,0,1,"","seamlessCubemap"]],"cuda.cudart.cudaTextureFilterMode":[[6,0,1,"","cudaFilterModeLinear"],[6,0,1,"","cudaFilterModePoint"]],"cuda.cudart.cudaTextureObject_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaTextureReadMode":[[6,0,1,"","cudaReadModeElementType"],[6,0,1,"","cudaReadModeNormalizedFloat"]],"cuda.cudart.cudaUUID_t":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.cudaUserObjectFlags":[[6,0,1,"","cudaUserObjectNoDestructorSync"]],"cuda.cudart.cudaUserObjectRetainFlags":[[6,0,1,"","cudaGraphUserObjectMove"]],"cuda.cudart.cudaUserObject_t":[[6,2,1,"","getPtr"]],"cuda.nvrtc":[[7,3,1,"","nvrtcAddNameExpression"],[7,3,1,"","nvrtcCompileProgram"],[7,3,1,"","nvrtcCreateProgram"],[7,3,1,"","nvrtcDestroyProgram"],[7,3,1,"","nvrtcGetCUBIN"],[7,3,1,"","nvrtcGetCUBINSize"],[7,3,1,"","nvrtcGetErrorString"],[7,3,1,"","nvrtcGetLoweredName"],[7,3,1,"","nvrtcGetNVVM"],[7,3,1,"","nvrtcGetNVVMSize"],[7,3,1,"","nvrtcGetNumSupportedArchs"],[7,3,1,"","nvrtcGetPTX"],[7,3,1,"","nvrtcGetPTXSize"],[7,3,1,"","nvrtcGetProgramLog"],[7,3,1,"","nvrtcGetProgramLogSize"],[7,3,1,"","nvrtcGetSupportedArchs"],[7,1,1,"","nvrtcProgram"],[7,1,1,"","nvrtcResult"],[7,3,1,"","nvrtcVersion"]],"cuda.nvrtc.nvrtcProgram":[[7,2,1,"","getPtr"]],"cuda.nvrtc.nvrtcResult":[[7,0,1,"","NVRTC_ERROR_BUILTIN_OPERATION_FAILURE"],[7,0,1,"","NVRTC_ERROR_COMPILATION"],[7,0,1,"","NVRTC_ERROR_INTERNAL_ERROR"],[7,0,1,"","NVRTC_ERROR_INVALID_INPUT"],[7,0,1,"","NVRTC_ERROR_INVALID_OPTION"],[7,0,1,"","NVRTC_ERROR_INVALID_PROGRAM"],[7,0,1,"","NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID"],[7,0,1,"","NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION"],[7,0,1,"","NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION"],[7,0,1,"","NVRTC_ERROR_OUT_OF_MEMORY"],[7,0,1,"","NVRTC_ERROR_PROGRAM_CREATION_FAILURE"],[7,0,1,"","NVRTC_SUCCESS"]]},objnames:{"0":["py","attribute","Python attribute"],"1":["py","class","Python class"],"2":["py","method","Python method"],"3":["py","function","Python function"]},objtypes:{"0":"py:attribute","1":"py:class","2":"py:method","3":"py:function"},terms:{"0":[3,4,5,6,7,9,10],"02":4,"03":7,"0b":[5,6],"1":[1,3,5,6,7,9,10,13,17],"10":[0,5,7],"100":[5,6],"1000":[5,6],"10000":6,"101":[5,6],"102":[5,6],"1024":[5,6],"103":[5,6],"104":[5,6],"105":[5,6],"106":[5,6],"107":[5,6],"1073741824":5,"1076m":9,"108":[5,6],"1080m":9,"109":[5,6],"11":[0,3,4,5,7,10],"110":[5,6],"11020":5,"11080":5,"111":[5,6],"112":[5,6],"113":[5,6],"114":[5,6],"115":[5,6],"116":[5,6],"117":[5,6],"118":[5,6],"119":[5,6],"12":[5,6,13],"120":[5,6],"121":[5,6],"122":[5,6],"123":5,"124":5,"125":5,"127":6,"128":[5,6],"128b":[5,6],"13":[5,6],"14":[5,6,7],"145":5,"146":5,"147":5,"148":5,"149":5,"15":[5,6],"150":5,"151":5,"152":5,"153":5,"154":5,"155":5,"156":5,"157":5,"158":5,"16":[5,6,11],"16f":[5,6],"16f_arb":[5,6],"16i":[5,6],"16i_ext":[5,6],"16ui":[5,6],"16ui_ext":[5,6],"17":[5,6,7],"176":5,"18":[5,6,12,14],"19":[5,6],"192":5,"193":5,"194":5,"195":5,"196":5,"197":5,"198":5,"199":5,"1d":[5,6],"2":[5,6,7,9,13,16],"20":[5,6],"200":[5,6],"201":[5,6],"202":5,"2021":[11,12],"2022":[13,14,15,16,17,18],"203":5,"2048":[5,6],"205":[5,6],"206":[5,6],"207":[5,6],"208":[5,6],"209":[5,6],"21":[5,6],"210":[5,6],"211":[5,6],"212":[5,6],"213":[5,6],"214":[5,6],"2147483647":[5,6],"215":[5,6],"216":[5,6],"217":[5,6],"218":[5,6,9],"219":[5,6],"22":[5,6,16],"220":[5,6],"221":[5,6],"222":[5,6],"223":[5,6],"224":[5,6],"23":[5,6],"24":[5,6,17],"241":6,"242":6,"25":[5,6],"252":6,"256":[5,6],"26":[5,6],"27":[5,6,18],"28":[5,6],"29":[5,6,16],"2d":[5,6],"3":[5,6,7,9,17],"30":[5,6],"300":[5,6],"301":[5,6],"3010":[5,6],"302":[5,6],"3020":[5,6],"303":[5,6],"304":[5,6],"31":[5,6],"32":[5,6],"32768":9,"32f":[5,6],"32f_arb":[5,6],"32i":[5,6],"32i_ext":[5,6],"32ui":[5,6],"32ui_ext":[5,6],"33":[5,6],"34":[5,6],"35":[5,6],"352\u00b5":9,"36":[5,6],"37":[5,6],"38":[4,5,6],"39":[5,6],"3d":[5,6],"3rd":5,"4":[1,3,5,6,7,9,10,18],"40":[5,6],"400":[5,6],"401":[5,6],"4020":5,"4096":5,"41":[5,6],"42":[5,6],"43":[5,6],"44":[5,6],"445":[5,6],"45":[5,6],"450":4,"456":4,"46":[5,6],"47":[5,6],"48":[5,6],"49":[5,6],"4x16":5,"5":[3,5,6,7,9,10],"50":[5,6],"500":[5,6],"51":[5,6],"512":[5,6,9],"52":[5,6],"53":[5,6],"54":[5,6],"55":[5,6],"56":[5,6],"57":[5,6],"58":[5,6],"59":[5,6],"6":[3,5,6,7,9,10],"60":[5,6],"600":[5,6],"61":[5,6],"62":[5,6],"63":[5,6],"64":[5,6],"65":[5,6],"66":[5,6],"67":[5,6],"68":[5,6],"69":[5,6],"7":[3,5,6,7,9,10,17],"70":[5,6],"700":[5,6],"701":[5,6],"702":[5,6],"703":[5,6],"704":[5,6],"705":[5,6],"708":[5,6],"709":[5,6],"71":[5,6],"710":[5,6],"711":[5,6],"712":[5,6],"713":[5,6],"714":[5,6],"715":[5,6],"716":[5,6],"717":[5,6],"718":[5,6],"719":[5,6],"72":[5,6],"720":[5,6],"73":[5,6],"74":[5,6],"75":[5,6,9],"76":[5,6],"77":[5,6],"78":[5,6],"79":[5,6],"8":[3,4,5,6,7,10],"80":[4,5,6],"800":[5,6],"801":[5,6],"802":[5,6],"803":[5,6],"804":[5,6],"805":[5,6],"806":[5,6],"807":[5,6],"808":[5,6],"809":[5,6],"81":[5,6],"810":[5,6],"8192":5,"82":[5,6],"83":[5,6],"84":[5,6],"85":[5,6],"86":[5,6],"87":[5,6],"88":[5,6],"89":[5,6],"8i":[5,6],"8i_ext":[5,6],"8ui":[5,6],"8ui_ext":[5,6],"9":[0,5,7],"90":[5,6],"900":[5,6],"901":[5,6],"902":[5,6],"9020":[5,6],"903":[5,6],"904":[5,6],"905":[5,6],"906":[5,6],"907":[5,6],"908":[5,6],"909":[5,6],"91":[5,6],"910":[5,6],"911":[5,6],"912":[5,6],"92":[5,6],"93":[5,6],"94":[5,6],"95":[5,6],"96":[5,6],"97":[5,6],"98":[5,6],"99":[5,6],"999":[5,6],"boolean":5,"break":5,"byte":[5,6,7],"case":[5,6],"char":[5,6,7,9],"class":[5,6,7,13],"const":5,"default":[5,6,7,10,12],"do":[1,2,5,6,7,9],"enum":[5,6],"export":[4,5,6,13],"float":[5,6,7,9],"function":[5,6,7,9,10],"import":[5,6,8,9],"int":[5,6,7,9],"long":[5,6,7,9],"new":[5,6,7,8],"null":[5,6,7],"public":1,"return":[5,6,7,9],"short":[5,7,16],"static":[5,6],"switch":6,"true":[5,6,7,9],"try":[5,6,9],"void":[5,6,9],"while":[5,6],A:[5,6,9,16],As:[5,6,16],At:[2,5,6],Being:1,But:[5,6],By:[5,6,17],For:[1,5,6,7,9],IN:5,If:[2,5,6,7,9],In:[1,5,6,7,8,9,16],It:[5,6,7,9,17],No:[5,6,7],Not:[5,6,10],OR:5,On:[5,6,7],One:9,Such:[5,6],That:[5,9],The:[1,2,4,5,6,7,8,9],Then:4,There:[5,6,9],These:[5,6,7],To:[4,5,6,7,9],With:[8,9],__constant__:7,__global__:9,__int128:7,__threadfence_system:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_memhandle_u:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_resource_u:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_subresource_u:5,_cuda_array_sparse_properties_v1_cuda_array_sparse_properties_v1_cuda_array_sparse_properties_st_tileextent_:5,_cuda_external_memory_handle_desc_v1_cuda_external_memory_handle_desc_v1_cuda_external_memory_handle_desc_st_handle_u:5,_cuda_external_semaphore_handle_desc_v1_cuda_external_semaphore_handle_desc_v1_cuda_external_semaphore_handle_desc_st_handle_u:5,_cuda_external_semaphore_signal_params_v1_cuda_external_semaphore_signal_params_v1_cuda_external_semaphore_signal_params_st_params_:5,_cuda_external_semaphore_wait_params_v1_cuda_external_semaphore_wait_params_v1_cuda_external_semaphore_wait_params_st_params_:5,_cuda_resource_desc_v1_cuda_resource_desc_v1_cuda_resource_desc_st_res_u:5,_cudaarraysparseproperties_tileextent_:6,_cudaeglframe_cudaeglframe_cudaeglframe_st_frame_u:6,_cudaexternalmemoryhandledesc_handle_u:6,_cudaexternalsemaphorehandledesc_handle_u:6,_cudaexternalsemaphoresignalparams_params_:6,_cudaexternalsemaphorewaitparams_params_:6,_cudalaunchattributevalue_cudalaunchattributevalue_cudalaunchattributevalue_clusterdim_:6,_cudalaunchattributevalue_cudalaunchattributevalue_cudalaunchattributevalue_programmaticevent_:6,_cudaresourcedesc_res_u:6,_cueglframe_v1_cueglframe_v1_cueglframe_st_frame_u:5,_cuexecaffinityparam_v1_cuexecaffinityparam_v1_cuexecaffinityparam_st_param_u:5,_culaunchattributevalue_culaunchattributevalue_culaunchattributevalue_union_clusterdim_:5,_culaunchattributevalue_culaunchattributevalue_culaunchattributevalue_union_programmaticevent_:5,_cumemallocationprop_v1_cumemallocationprop_v1_cumemallocationprop_st_allocflags_:5,_ptr:[5,6],_v2:5,abbrevi:[5,6],abgr:[5,6],abi:[5,6,7],abl:[5,6],about:[1,5,6],abov:[4,5,6,9],absent:[5,6],abus:1,acceler:[5,6,8,9],accept:[1,2,5,6,13],acces:[5,6],access:[0,8,9,16],accessdesc:[5,6],accessdesccount:[5,6],accesspolicymaxwindows:6,accesspolicywindow:[5,6],accomplish:[5,6],accord:[5,6],accordingli:[5,6],account:[1,5],accumul:5,achiev:5,acquir:[5,6],across:[5,6],act:1,action:[1,5,6],activ:[4,5,6],actual:[5,6,7],ad:[5,6],adapt:1,add:[5,6,7],addit:[5,6,9],addition:[5,6],addr:5,address:[0,1,7],addressmod:[5,6],advanc:[1,5,6],advers:[5,6],advic:[5,6],advis:[5,6],affect:[5,6],affin:[5,6],after:[5,6,7,9],afterward:5,ag:1,again:[5,6],against:[5,6],aggress:7,agnost:[5,6],ahead:9,ai:8,alia:6,align:[1,5,6],all:[1,4,5,6,7,9,11,12,16,17],allclos:9,alloc:[0,7,9],allocat:[5,6],allocflag:5,alloctyp:[5,6],allow:[5,6,7,8,9,17],along:[5,6,7],alpha:[5,6],alreadi:[5,6],also:[5,6,7,8,9],alter:[5,6],altern:[5,6,7],although:[5,6],alwai:[5,6],among:[5,6,9],amount:[5,6,7],an:[1,2,5,6,7,8,9,13],anaconda:8,analog:9,analyt:[8,9],ani:[1,5,6,7,9],anisotrop:[5,6],anisotropi:[5,6],anistropi:6,annot:7,anoth:[5,6,9],answer:1,anymor:5,api:[3,5,7,8,9,13,14,15,16,17,18],app:[5,6],appear:[1,5,7],appli:[1,5,6],applic:[5,6,8],applicaton:[5,6],appoint:1,appropri:[1,5,6],approprri:6,approx:[5,6],approxim:[5,7],ar:[1,4,5,6,7,8,9,13,16],arbitrari:[5,6],arch:7,architectur:[5,6,7,9],archiv:5,area:[5,6],arg:[5,6,7,9],argb:[5,6],argument:[4,5,6,7,9],arithmet:6,arm:5,around:[5,6],arrai:[5,6,7,8,9],arraydesc:5,arrayindex:[5,6],arriv:5,ascend:7,ascii:[5,6],assembl:7,assert:[5,6,7,9],assert_drv:9,assign:[5,6,7,9],assist:5,associ:[5,6,9],assum:[5,6,7],assumpt:6,astyp:9,async:[5,6],asyncenginecount:6,asynchron:[5,6,9],atom:[5,6],atribut:5,attach:[5,6],attack:1,attempt:[5,6],attent:[1,2],attr:[5,6],attrib:[5,6],attribut:[3,5,6],august:11,auto:6,automat:[5,6,9],avail:[1,5,6,7],availab:5,avoid:[5,6],avui:[5,6],b:[5,6,9],back:[5,6,9],balanc:[5,6],ban:1,bandwidth:[5,6],bank:[5,6],barfoo:5,barfoobaz:5,barrier:[5,6,8],base:[2,5,6,8],base_ptr:[5,6],basic:[5,6,9],batch:5,bayer10:[5,6],bayer12:[5,6],bayer14:[5,6],bayer20:[5,6],bayer:[5,6],bc1:[5,6],bc2:[5,6],bc3:[5,6],bc4:[5,6],bc5:[5,6],bc6h:[5,6],bc7:[5,6],bc:[5,6],bccr:[5,6],becaus:[5,6,7,9],becom:[5,6],been:[5,6,7,9,16],befor:[5,6,9,13],begin:[5,6],begun:[5,6],behav:[5,6],behavior:[1,5,6,13],behind:[5,6],being:[5,6],believ:2,belong:[5,6],below:[5,6,7],benefit:8,besid:6,best:[1,5,6,8,9],better:6,between:[5,6,7,9],betwen:6,beyond:[5,6],bggr:[5,6],bgr:5,bgra:[5,6],bia:5,bilinear:5,binari:[5,6],binaryvers:6,bind:[4,5,6,8,9,11,12,16],bit:[5,6],bitmask:[5,6],block:[5,6,7,9],blockdim:[6,9],blockdimi:5,blockdimx:5,blockdimz:5,blockidx:9,blocksiz:[5,6],blocksizelimit:5,blocksizetodynamicsmems:5,board:[5,6],bodi:1,border:[5,6],bordercolor:[5,6],both:[1,5,6,8],bound:[5,6],boundari:[5,6],breadth:5,breviti:[5,6,9],bu:[5,6],buffer:[5,6],bufferdesc:[5,6],buffers:[5,6,9],bug:2,build:[3,8,9,10],build_ext:4,built:[6,9],builtin:[5,7],bump:7,bundl:5,burden:[5,6],busi:[5,6],bytecount:5,bytes:[5,6],c:[0,4,5,7,9,16],ca:[5,6],cach:[5,6],cacheconfig:6,cachemodeca:6,calcul:[5,6],call:[5,6,7,9],callback:[5,6],caller:[5,6],can:[4,5,6,7,8,9],canaccessp:[5,6],cancel:7,canmaphostmemori:6,cannot:[5,6],canusehostpointerforregisteredmem:6,cap:5,capabl:[5,6,8,9],capac:[5,6],captur:[5,6],capturestatu:[5,6],capturestatus_out:[5,6],card:6,carveout:[5,6],cast:[5,6],categori:2,caus:[5,6,7],cbrc:[5,6],cccc:[5,6],cd:4,cdp:[5,6],cell:9,certain:[5,6,16],chain:[5,6],chang:[2,5,6,7,9,12,13],channel:[5,6],channeldesc:6,chapter:[5,6],charact:[5,6,7],characterist:1,check:[5,6,9],checkout:4,child:[5,6],childgraph:[5,6],chip:6,choic:5,choos:[5,6],chosen:[5,6],circumst:[1,5,6],cl_context_flag:5,cl_event_flag:5,clamp:[5,6],clarifi:1,clean:[5,6,9],clear:[5,6],cli:9,client:[5,6],clock:[5,6],clockrat:[5,6],clone:[5,6],clonedgraph:6,close:[5,6,9],cluster:[5,6],clusterdim:[5,6],clusters:5,clusterschedulingpolicyprefer:[5,6],co:5,coalesc:[5,6],code:[2,3,5,6,7,8,9,11],coher:[5,6],collaps:[5,6],collect:[5,6],color:[5,6],column:[5,6],com:[1,5,6,16],combin:[5,6],come:[5,6,11,12],comma:[6,7],command:[5,6,9],comment:[1,2],commit:[1,5,6,9],common:[1,5,6,9],commonli:[5,6,9],commun:1,compar:[5,6,9],comparison:5,compat:[4,5,6,8,9],compil:[0,4,5,6,8,9],complaint:1,complet:[5,6,9],compliant:[5,6],compon:[4,5,6],compos:8,composit:[5,6],compress:[5,6],comput:[5,6,8,9],compute_35:7,compute_37:7,compute_50:7,compute_52:7,compute_53:7,compute_60:7,compute_61:7,compute_62:7,compute_70:7,compute_72:7,compute_75:[7,9],compute_80:7,compute_87:7,compute_89:7,compute_90:7,computemod:6,computepreemptionsupport:6,concept:9,concurr:[5,6],concurrentkernel:6,concurrentmanagedaccess:6,conda:[3,12],condit:[5,6],conduct:3,conect:[5,6],confidenti:1,config:[5,6],configur:[5,6,9],conflict:[5,6],conjunct:5,conn:[5,6],connect:[5,6],consecut:[5,6],consid:[1,5,6,7],consist:[5,6],constant:[5,6,7],constantli:[5,6],constitut:5,constrain:[5,6],constraint:[5,6],constrast:6,construct:[1,5,6,9],constsizebyt:6,consum:[5,6],consumpt:[5,6],contact:1,contain:[5,6,7],content:[5,6,7],context:[0,6,9],contigu:[5,6,9],contingu:5,continu:[5,6],contract:[5,6,7],contrari:6,contrast:5,contribut:[1,3,5,6],contributor:1,control:[0,9],conveni:[5,6],convent:[5,6],convers:[5,6],convert:[5,6],cooper:[5,6],cooperativelaunch:6,cooperativemultidevicelaunch:6,coordin:[5,6],copi:[5,6,9],copyparam:5,corner:6,correct:[1,5,6,9],correctli:5,correspon:5,correspond:[5,6,7],corrupt:[5,6],cost:[5,6],could:[1,5,6],count:[5,6],counter:[5,6],counterpart:[5,6],coven:1,coverag:[8,9],cp:4,cpu:[5,6,8,9],crbc:[5,6],creat:[1,4,5,6,7,9],createsharedhandl:[5,6],creation:[5,6,9],criteria:6,critic:1,cross:[5,6],ctk:[4,16,17,18],ctx:5,ctype:9,cu:9,cu_access_property_norm:5,cu_access_property_persist:5,cu_access_property_stream:5,cu_ad_format_bc1_unorm:5,cu_ad_format_bc1_unorm_srgb:5,cu_ad_format_bc2_unorm:5,cu_ad_format_bc2_unorm_srgb:5,cu_ad_format_bc3_unorm:5,cu_ad_format_bc3_unorm_srgb:5,cu_ad_format_bc4_snorm:5,cu_ad_format_bc4_unorm:5,cu_ad_format_bc5_snorm:5,cu_ad_format_bc5_unorm:5,cu_ad_format_bc6h_sf16:5,cu_ad_format_bc6h_uf16:5,cu_ad_format_bc7_unorm:5,cu_ad_format_bc7_unorm_srgb:5,cu_ad_format_float:5,cu_ad_format_half:5,cu_ad_format_nv12:5,cu_ad_format_signed_int16:5,cu_ad_format_signed_int32:5,cu_ad_format_signed_int8:5,cu_ad_format_snorm_int16x1:5,cu_ad_format_snorm_int16x2:5,cu_ad_format_snorm_int16x4:5,cu_ad_format_snorm_int8x1:5,cu_ad_format_snorm_int8x2:5,cu_ad_format_snorm_int8x4:5,cu_ad_format_unorm_int16x1:5,cu_ad_format_unorm_int16x2:5,cu_ad_format_unorm_int16x4:5,cu_ad_format_unorm_int8x1:5,cu_ad_format_unorm_int8x2:5,cu_ad_format_unorm_int8x4:5,cu_ad_format_unsigned_int16:5,cu_ad_format_unsigned_int32:5,cu_ad_format_unsigned_int8:5,cu_array_sparse_properties_single_miptail:5,cu_array_sparse_subresource_type_miptail:5,cu_array_sparse_subresource_type_sparse_level:5,cu_cluster_scheduling_policy_default:5,cu_cluster_scheduling_policy_load_balanc:5,cu_cluster_scheduling_policy_spread:5,cu_computemode_default:5,cu_computemode_exclusive_process:5,cu_computemode_prohibit:5,cu_ctx_blocking_sync:5,cu_ctx_flags_mask:5,cu_ctx_lmem_resize_to_max:5,cu_ctx_map_host:5,cu_ctx_sched_auto:5,cu_ctx_sched_blocking_sync:5,cu_ctx_sched_mask:5,cu_ctx_sched_spin:5,cu_ctx_sched_yield:5,cu_cubemap_face_negative_i:5,cu_cubemap_face_negative_x:5,cu_cubemap_face_negative_z:5,cu_cubemap_face_positive_i:5,cu_cubemap_face_positive_x:5,cu_cubemap_face_positive_z:5,cu_device_attribute_async_engine_count:5,cu_device_attribute_can_flush_remote_writ:5,cu_device_attribute_can_map_host_memori:5,cu_device_attribute_can_tex2d_gath:5,cu_device_attribute_can_use_64_bit_stream_mem_op:5,cu_device_attribute_can_use_64_bit_stream_mem_ops_v2:5,cu_device_attribute_can_use_host_pointer_for_registered_mem:5,cu_device_attribute_can_use_stream_mem_op:5,cu_device_attribute_can_use_stream_wait_value_nor:5,cu_device_attribute_can_use_stream_wait_value_nor_v2:5,cu_device_attribute_clock_r:5,cu_device_attribute_cluster_launch:5,cu_device_attribute_compute_capability_major:5,cu_device_attribute_compute_capability_minor:5,cu_device_attribute_compute_mod:5,cu_device_attribute_compute_preemption_support:5,cu_device_attribute_concurrent_kernel:5,cu_device_attribute_concurrent_managed_access:5,cu_device_attribute_cooperative_launch:5,cu_device_attribute_cooperative_multi_device_launch:5,cu_device_attribute_deferred_mapping_cuda_array_support:5,cu_device_attribute_direct_managed_mem_access_from_host:5,cu_device_attribute_dma_buf_support:5,cu_device_attribute_ecc_en:5,cu_device_attribute_flush_flush_gpu_direct_rdma_opt:5,cu_device_attribute_generic_compression_support:5,cu_device_attribute_global_l1_cache_support:5,cu_device_attribute_global_memory_bus_width:5,cu_device_attribute_gpu_direct_rdma_flush_writes_opt:5,cu_device_attribute_gpu_direct_rdma_support:5,cu_device_attribute_gpu_direct_rdma_with_cuda_vmm_support:5,cu_device_attribute_gpu_direct_rdma_writes_ord:5,cu_device_attribute_gpu_overlap:5,cu_device_attribute_handle_type_posix_file_descriptor_support:5,cu_device_attribute_handle_type_win32_handle_support:5,cu_device_attribute_handle_type_win32_kmt_handle_support:5,cu_device_attribute_host_native_atomic_support:5,cu_device_attribute_host_register_support:5,cu_device_attribute_integr:5,cu_device_attribute_kernel_exec_timeout:5,cu_device_attribute_l2_cache_s:5,cu_device_attribute_local_l1_cache_support:5,cu_device_attribute_managed_memori:5,cu_device_attribute_max:5,cu_device_attribute_max_access_policy_window_s:5,cu_device_attribute_max_block_dim_i:5,cu_device_attribute_max_block_dim_x:5,cu_device_attribute_max_block_dim_z:5,cu_device_attribute_max_blocks_per_multiprocessor:5,cu_device_attribute_max_grid_dim_i:5,cu_device_attribute_max_grid_dim_x:5,cu_device_attribute_max_grid_dim_z:5,cu_device_attribute_max_persisting_l2_cache_s:5,cu_device_attribute_max_pitch:5,cu_device_attribute_max_registers_per_block:5,cu_device_attribute_max_registers_per_multiprocessor:5,cu_device_attribute_max_shared_memory_per_block:5,cu_device_attribute_max_shared_memory_per_block_optin:5,cu_device_attribute_max_shared_memory_per_multiprocessor:5,cu_device_attribute_max_threads_per_block:5,cu_device_attribute_max_threads_per_multiprocessor:5,cu_device_attribute_maximum_surface1d_layered_lay:5,cu_device_attribute_maximum_surface1d_layered_width:5,cu_device_attribute_maximum_surface1d_width:5,cu_device_attribute_maximum_surface2d_height:5,cu_device_attribute_maximum_surface2d_layered_height:5,cu_device_attribute_maximum_surface2d_layered_lay:5,cu_device_attribute_maximum_surface2d_layered_width:5,cu_device_attribute_maximum_surface2d_width:5,cu_device_attribute_maximum_surface3d_depth:5,cu_device_attribute_maximum_surface3d_height:5,cu_device_attribute_maximum_surface3d_width:5,cu_device_attribute_maximum_surfacecubemap_layered_lay:5,cu_device_attribute_maximum_surfacecubemap_layered_width:5,cu_device_attribute_maximum_surfacecubemap_width:5,cu_device_attribute_maximum_texture1d_layered_lay:5,cu_device_attribute_maximum_texture1d_layered_width:5,cu_device_attribute_maximum_texture1d_linear_width:5,cu_device_attribute_maximum_texture1d_mipmapped_width:5,cu_device_attribute_maximum_texture1d_width:5,cu_device_attribute_maximum_texture2d_array_height:5,cu_device_attribute_maximum_texture2d_array_numslic:5,cu_device_attribute_maximum_texture2d_array_width:5,cu_device_attribute_maximum_texture2d_gather_height:5,cu_device_attribute_maximum_texture2d_gather_width:5,cu_device_attribute_maximum_texture2d_height:5,cu_device_attribute_maximum_texture2d_layered_height:5,cu_device_attribute_maximum_texture2d_layered_lay:5,cu_device_attribute_maximum_texture2d_layered_width:5,cu_device_attribute_maximum_texture2d_linear_height:5,cu_device_attribute_maximum_texture2d_linear_pitch:5,cu_device_attribute_maximum_texture2d_linear_width:5,cu_device_attribute_maximum_texture2d_mipmapped_height:5,cu_device_attribute_maximum_texture2d_mipmapped_width:5,cu_device_attribute_maximum_texture2d_width:5,cu_device_attribute_maximum_texture3d_depth:5,cu_device_attribute_maximum_texture3d_depth_altern:5,cu_device_attribute_maximum_texture3d_height:5,cu_device_attribute_maximum_texture3d_height_altern:5,cu_device_attribute_maximum_texture3d_width:5,cu_device_attribute_maximum_texture3d_width_altern:5,cu_device_attribute_maximum_texturecubemap_layered_lay:5,cu_device_attribute_maximum_texturecubemap_layered_width:5,cu_device_attribute_maximum_texturecubemap_width:5,cu_device_attribute_memory_clock_r:5,cu_device_attribute_memory_pools_support:5,cu_device_attribute_mempool_supported_handle_typ:5,cu_device_attribute_multi_gpu_board:5,cu_device_attribute_multi_gpu_board_group_id:5,cu_device_attribute_multiprocessor_count:5,cu_device_attribute_pageable_memory_access:5,cu_device_attribute_pageable_memory_access_uses_host_page_t:5,cu_device_attribute_pci_bus_id:5,cu_device_attribute_pci_device_id:5,cu_device_attribute_pci_domain_id:5,cu_device_attribute_read_only_host_register_support:5,cu_device_attribute_registers_per_block:5,cu_device_attribute_reserved_shared_memory_per_block:5,cu_device_attribute_shared_memory_per_block:5,cu_device_attribute_single_to_double_precision_perf_ratio:5,cu_device_attribute_sparse_cuda_array_support:5,cu_device_attribute_stream_priorities_support:5,cu_device_attribute_surface_align:5,cu_device_attribute_tcc_driv:5,cu_device_attribute_texture_align:5,cu_device_attribute_texture_pitch_align:5,cu_device_attribute_timeline_semaphore_interop_support:5,cu_device_attribute_total_constant_memori:5,cu_device_attribute_unified_address:5,cu_device_attribute_virtual_address_management_support:5,cu_device_attribute_virtual_memory_management_support:5,cu_device_attribute_warp_s:5,cu_device_cpu:5,cu_device_invalid:5,cu_device_p2p_attribute_access_access_support:5,cu_device_p2p_attribute_access_support:5,cu_device_p2p_attribute_cuda_array_access_support:5,cu_device_p2p_attribute_native_atomic_support:5,cu_device_p2p_attribute_performance_rank:5,cu_egl_color_format_a:5,cu_egl_color_format_abgr:5,cu_egl_color_format_argb:5,cu_egl_color_format_ayuv:5,cu_egl_color_format_ayuv_:5,cu_egl_color_format_bayer10_bggr:5,cu_egl_color_format_bayer10_cccc:5,cu_egl_color_format_bayer10_gbrg:5,cu_egl_color_format_bayer10_grbg:5,cu_egl_color_format_bayer10_rggb:5,cu_egl_color_format_bayer12_bccr:5,cu_egl_color_format_bayer12_bggr:5,cu_egl_color_format_bayer12_cbrc:5,cu_egl_color_format_bayer12_cccc:5,cu_egl_color_format_bayer12_crbc:5,cu_egl_color_format_bayer12_gbrg:5,cu_egl_color_format_bayer12_grbg:5,cu_egl_color_format_bayer12_rccb:5,cu_egl_color_format_bayer12_rggb:5,cu_egl_color_format_bayer14_bggr:5,cu_egl_color_format_bayer14_gbrg:5,cu_egl_color_format_bayer14_grbg:5,cu_egl_color_format_bayer14_rggb:5,cu_egl_color_format_bayer20_bggr:5,cu_egl_color_format_bayer20_gbrg:5,cu_egl_color_format_bayer20_grbg:5,cu_egl_color_format_bayer20_rggb:5,cu_egl_color_format_bayer_bccr:5,cu_egl_color_format_bayer_bggr:5,cu_egl_color_format_bayer_cbrc:5,cu_egl_color_format_bayer_crbc:5,cu_egl_color_format_bayer_gbrg:5,cu_egl_color_format_bayer_grbg:5,cu_egl_color_format_bayer_isp_bggr:5,cu_egl_color_format_bayer_isp_gbrg:5,cu_egl_color_format_bayer_isp_grbg:5,cu_egl_color_format_bayer_isp_rggb:5,cu_egl_color_format_bayer_rccb:5,cu_egl_color_format_bayer_rggb:5,cu_egl_color_format_bgr:5,cu_egl_color_format_bgra:5,cu_egl_color_format_i:5,cu_egl_color_format_l:5,cu_egl_color_format_max:5,cu_egl_color_format_r:5,cu_egl_color_format_rg:5,cu_egl_color_format_rgb:5,cu_egl_color_format_rgba:5,cu_egl_color_format_uyvy_422:5,cu_egl_color_format_uyvy_:5,cu_egl_color_format_vyui:5,cu_egl_color_format_vyuy_:5,cu_egl_color_format_y10_709_:5,cu_egl_color_format_y10_:5,cu_egl_color_format_y10v10u10_420_semiplanar:5,cu_egl_color_format_y10v10u10_420_semiplanar_2020:5,cu_egl_color_format_y10v10u10_420_semiplanar_709:5,cu_egl_color_format_y10v10u10_420_semiplanar_709_:5,cu_egl_color_format_y10v10u10_420_semiplanar_:5,cu_egl_color_format_y10v10u10_422_semiplanar:5,cu_egl_color_format_y10v10u10_422_semiplanar_2020:5,cu_egl_color_format_y10v10u10_422_semiplanar_709:5,cu_egl_color_format_y10v10u10_444_semiplanar:5,cu_egl_color_format_y10v10u10_444_semiplanar_709_:5,cu_egl_color_format_y10v10u10_444_semiplanar_:5,cu_egl_color_format_y12_709_:5,cu_egl_color_format_y12_:5,cu_egl_color_format_y12v12u12_420_semiplanar:5,cu_egl_color_format_y12v12u12_420_semiplanar_709_:5,cu_egl_color_format_y12v12u12_420_semiplanar_:5,cu_egl_color_format_y12v12u12_444_semiplanar:5,cu_egl_color_format_y12v12u12_444_semiplanar_709_:5,cu_egl_color_format_y12v12u12_444_semiplanar_:5,cu_egl_color_format_y_709_:5,cu_egl_color_format_y_:5,cu_egl_color_format_yuv420_planar:5,cu_egl_color_format_yuv420_planar_2020:5,cu_egl_color_format_yuv420_planar_709:5,cu_egl_color_format_yuv420_planar_:5,cu_egl_color_format_yuv420_semiplanar:5,cu_egl_color_format_yuv420_semiplanar_2020:5,cu_egl_color_format_yuv420_semiplanar_709:5,cu_egl_color_format_yuv420_semiplanar_:5,cu_egl_color_format_yuv422_planar:5,cu_egl_color_format_yuv422_planar_:5,cu_egl_color_format_yuv422_semiplanar:5,cu_egl_color_format_yuv422_semiplanar_:5,cu_egl_color_format_yuv444_planar:5,cu_egl_color_format_yuv444_planar_:5,cu_egl_color_format_yuv444_semiplanar:5,cu_egl_color_format_yuv444_semiplanar_:5,cu_egl_color_format_yuv:5,cu_egl_color_format_yuv_:5,cu_egl_color_format_yuva:5,cu_egl_color_format_yuva_:5,cu_egl_color_format_yuyv_422:5,cu_egl_color_format_yuyv_:5,cu_egl_color_format_yvu420_planar:5,cu_egl_color_format_yvu420_planar_2020:5,cu_egl_color_format_yvu420_planar_709:5,cu_egl_color_format_yvu420_planar_:5,cu_egl_color_format_yvu420_semiplanar:5,cu_egl_color_format_yvu420_semiplanar_2020:5,cu_egl_color_format_yvu420_semiplanar_709:5,cu_egl_color_format_yvu420_semiplanar_:5,cu_egl_color_format_yvu422_planar:5,cu_egl_color_format_yvu422_planar_:5,cu_egl_color_format_yvu422_semiplanar:5,cu_egl_color_format_yvu422_semiplanar_:5,cu_egl_color_format_yvu444_planar:5,cu_egl_color_format_yvu444_planar_:5,cu_egl_color_format_yvu444_semiplanar:5,cu_egl_color_format_yvu444_semiplanar_:5,cu_egl_color_format_yvyu:5,cu_egl_color_format_yvyu_:5,cu_egl_frame_type_arrai:5,cu_egl_frame_type_pitch:5,cu_egl_resource_location_sysmem:5,cu_egl_resource_location_vidmem:5,cu_event_blocking_sync:5,cu_event_default:5,cu_event_disable_tim:5,cu_event_interprocess:5,cu_event_record_default:5,cu_event_record_extern:5,cu_event_sched_auto:5,cu_event_sched_blocking_sync:5,cu_event_sched_spin:5,cu_event_sched_yield:5,cu_event_wait_default:5,cu_event_wait_extern:5,cu_exec_affinity_type_max:5,cu_exec_affinity_type_sm_count:5,cu_external_memory_handle_type_d3d11_resourc:5,cu_external_memory_handle_type_d3d11_resource_kmt:5,cu_external_memory_handle_type_d3d12_heap:5,cu_external_memory_handle_type_d3d12_resourc:5,cu_external_memory_handle_type_nvscibuf:5,cu_external_memory_handle_type_opaque_fd:5,cu_external_memory_handle_type_opaque_win32:5,cu_external_memory_handle_type_opaque_win32_kmt:5,cu_external_semaphore_handle_type_d3d11_f:5,cu_external_semaphore_handle_type_d3d11_keyed_mutex:5,cu_external_semaphore_handle_type_d3d11_keyed_mutex_kmt:5,cu_external_semaphore_handle_type_d3d12_f:5,cu_external_semaphore_handle_type_nvscisync:5,cu_external_semaphore_handle_type_opaque_fd:5,cu_external_semaphore_handle_type_opaque_win32:5,cu_external_semaphore_handle_type_opaque_win32_kmt:5,cu_external_semaphore_handle_type_timeline_semaphore_fd:5,cu_external_semaphore_handle_type_timeline_semaphore_win32:5,cu_flush_gpu_direct_rdma_writes_option_host:5,cu_flush_gpu_direct_rdma_writes_option_memop:5,cu_flush_gpu_direct_rdma_writes_target_current_ctx:5,cu_flush_gpu_direct_rdma_writes_to_all_devic:5,cu_flush_gpu_direct_rdma_writes_to_own:5,cu_func_attribute_binary_vers:5,cu_func_attribute_cache_mode_ca:5,cu_func_attribute_cluster_scheduling_policy_prefer:5,cu_func_attribute_cluster_size_must_be_set:5,cu_func_attribute_const_size_byt:5,cu_func_attribute_local_size_byt:5,cu_func_attribute_max:5,cu_func_attribute_max_dynamic_shared_size_byt:5,cu_func_attribute_max_threads_per_block:5,cu_func_attribute_non_portable_cluster_size_allow:5,cu_func_attribute_num_reg:5,cu_func_attribute_preferred_shared_memory_carveout:5,cu_func_attribute_ptx_vers:5,cu_func_attribute_required_cluster_depth:5,cu_func_attribute_required_cluster_height:5,cu_func_attribute_required_cluster_width:5,cu_func_attribute_shared_size_byt:5,cu_func_cache_mode_ca:5,cu_func_cache_prefer_equ:5,cu_func_cache_prefer_l1:5,cu_func_cache_prefer_non:5,cu_func_cache_prefer_shar:5,cu_get_proc_address_default:5,cu_get_proc_address_legacy_stream:5,cu_get_proc_address_per_thread_default_stream:5,cu_gl_device_list_al:5,cu_gl_device_list_current_fram:5,cu_gl_device_list_next_fram:5,cu_gpu_direct_rdma_writes_ordering_all_devic:5,cu_gpu_direct_rdma_writes_ordering_non:5,cu_gpu_direct_rdma_writes_ordering_own:5,cu_graph_debug_dot_flags_batch_mem_op_node_param:5,cu_graph_debug_dot_flags_event_node_param:5,cu_graph_debug_dot_flags_ext_semas_signal_node_param:5,cu_graph_debug_dot_flags_ext_semas_wait_node_param:5,cu_graph_debug_dot_flags_handl:5,cu_graph_debug_dot_flags_host_node_param:5,cu_graph_debug_dot_flags_kernel_node_attribut:5,cu_graph_debug_dot_flags_kernel_node_param:5,cu_graph_debug_dot_flags_mem_alloc_node_param:5,cu_graph_debug_dot_flags_mem_free_node_param:5,cu_graph_debug_dot_flags_memcpy_node_param:5,cu_graph_debug_dot_flags_memset_node_param:5,cu_graph_debug_dot_flags_runtime_typ:5,cu_graph_debug_dot_flags_verbos:5,cu_graph_exec_update_error:5,cu_graph_exec_update_error_attributes_chang:5,cu_graph_exec_update_error_function_chang:5,cu_graph_exec_update_error_node_type_chang:5,cu_graph_exec_update_error_not_support:5,cu_graph_exec_update_error_parameters_chang:5,cu_graph_exec_update_error_topology_chang:5,cu_graph_exec_update_error_unsupported_function_chang:5,cu_graph_exec_update_success:5,cu_graph_mem_attr_reserved_mem_curr:5,cu_graph_mem_attr_reserved_mem_high:5,cu_graph_mem_attr_used_mem_curr:5,cu_graph_mem_attr_used_mem_high:5,cu_graph_node_type_batch_mem_op:5,cu_graph_node_type_empti:5,cu_graph_node_type_event_record:5,cu_graph_node_type_ext_semas_sign:5,cu_graph_node_type_ext_semas_wait:5,cu_graph_node_type_graph:5,cu_graph_node_type_host:5,cu_graph_node_type_kernel:5,cu_graph_node_type_mem_alloc:5,cu_graph_node_type_mem_fre:5,cu_graph_node_type_memcpi:5,cu_graph_node_type_memset:5,cu_graph_node_type_wait_ev:5,cu_graph_user_object_mov:5,cu_graphics_map_resource_flags_non:5,cu_graphics_map_resource_flags_read_onli:5,cu_graphics_map_resource_flags_readonli:5,cu_graphics_map_resource_flags_write_discard:5,cu_graphics_map_resource_flags_writediscard:5,cu_graphics_register_flags_non:5,cu_graphics_register_flags_read_onli:5,cu_graphics_register_flags_surface_ldst:5,cu_graphics_register_flags_texture_gath:5,cu_graphics_register_flags_write_discard:5,cu_ipc_handle_s:5,cu_ipc_mem_lazy_enable_peer_access:5,cu_jit_cache_mod:5,cu_jit_cache_option_ca:5,cu_jit_cache_option_cg:5,cu_jit_cache_option_non:5,cu_jit_error_log_buff:5,cu_jit_error_log_buffer_size_byt:5,cu_jit_fallback_strategi:5,cu_jit_fast_compil:5,cu_jit_fma:5,cu_jit_ftz:5,cu_jit_generate_debug_info:5,cu_jit_generate_line_info:5,cu_jit_global_symbol_address:5,cu_jit_global_symbol_count:5,cu_jit_global_symbol_nam:5,cu_jit_info_log_buff:5,cu_jit_info_log_buffer_size_byt:5,cu_jit_input_cubin:5,cu_jit_input_fatbinari:5,cu_jit_input_librari:5,cu_jit_input_nvvm:5,cu_jit_input_object:5,cu_jit_input_ptx:5,cu_jit_log_verbos:5,cu_jit_lto:5,cu_jit_max_regist:5,cu_jit_new_sm3x_opt:5,cu_jit_num_input_typ:5,cu_jit_num_opt:5,cu_jit_optimization_level:5,cu_jit_optimize_unused_device_vari:5,cu_jit_prec_div:5,cu_jit_prec_sqrt:5,cu_jit_referenced_kernel_count:5,cu_jit_referenced_kernel_nam:5,cu_jit_referenced_variable_count:5,cu_jit_referenced_variable_nam:5,cu_jit_target:5,cu_jit_target_from_cucontext:5,cu_jit_threads_per_block:5,cu_jit_wall_tim:5,cu_kernel_node_attribute_access_policy_window:5,cu_kernel_node_attribute_cluster_dimens:5,cu_kernel_node_attribute_cluster_scheduling_policy_prefer:5,cu_kernel_node_attribute_coop:5,cu_kernel_node_attribute_prior:5,cu_launch_attribute_access_policy_window:5,cu_launch_attribute_cluster_dimens:5,cu_launch_attribute_cluster_scheduling_policy_prefer:5,cu_launch_attribute_coop:5,cu_launch_attribute_ignor:5,cu_launch_attribute_prior:5,cu_launch_attribute_programmatic_ev:5,cu_launch_attribute_programmatic_stream_seri:5,cu_launch_attribute_synchronization_polici:5,cu_launch_param_buffer_point:[5,6],cu_launch_param_buffer_pointer_as_int:5,cu_launch_param_buffer_s:[5,6],cu_launch_param_buffer_size_as_int:5,cu_launch_param_end:[5,6],cu_launch_param_end_as_int:5,cu_limit_dev_runtime_pending_launch_count:5,cu_limit_dev_runtime_sync_depth:5,cu_limit_malloc_heap_s:5,cu_limit_max:5,cu_limit_max_l2_fetch_granular:5,cu_limit_persisting_l2_cache_s:5,cu_limit_printf_fifo_s:5,cu_limit_stack_s:5,cu_mem_access_flags_prot_max:5,cu_mem_access_flags_prot_non:5,cu_mem_access_flags_prot_read:5,cu_mem_access_flags_prot_readwrit:5,cu_mem_advise_set_accessed_bi:5,cu_mem_advise_set_preferred_loc:5,cu_mem_advise_set_read_mostli:5,cu_mem_advise_unset_accessed_bi:5,cu_mem_advise_unset_preferred_loc:5,cu_mem_advise_unset_read_mostli:5,cu_mem_alloc_granularity_minimum:5,cu_mem_alloc_granularity_recommend:5,cu_mem_allocation_comp_gener:5,cu_mem_allocation_comp_non:5,cu_mem_allocation_type_invalid:5,cu_mem_allocation_type_max:5,cu_mem_allocation_type_pin:5,cu_mem_attach_glob:5,cu_mem_attach_host:5,cu_mem_attach_singl:5,cu_mem_create_usage_tile_pool:5,cu_mem_handle_type_gener:5,cu_mem_handle_type_max:5,cu_mem_handle_type_non:5,cu_mem_handle_type_posix_file_descriptor:5,cu_mem_handle_type_win32:5,cu_mem_handle_type_win32_kmt:5,cu_mem_location_type_devic:5,cu_mem_location_type_invalid:5,cu_mem_location_type_max:5,cu_mem_operation_type_map:5,cu_mem_operation_type_unmap:5,cu_mem_range_attribute_accessed_bi:5,cu_mem_range_attribute_last_prefetch_loc:5,cu_mem_range_attribute_preferred_loc:5,cu_mem_range_attribute_read_mostli:5,cu_mem_range_handle_type_dma_buf_fd:5,cu_mem_range_handle_type_max:5,cu_memhostalloc_devicemap:5,cu_memhostalloc_port:5,cu_memhostalloc_writecombin:5,cu_memhostergister_read_onli:5,cu_memhostregister_devicemap:5,cu_memhostregister_iomemori:5,cu_memhostregister_port:5,cu_memhostregister_read_onli:5,cu_memorytype_arrai:[5,6],cu_memorytype_devic:[5,6],cu_memorytype_host:5,cu_memorytype_unifi:5,cu_mempool_attr_release_threshold:5,cu_mempool_attr_reserved_mem_curr:5,cu_mempool_attr_reserved_mem_high:5,cu_mempool_attr_reuse_allow_internal_depend:5,cu_mempool_attr_reuse_allow_opportunist:5,cu_mempool_attr_reuse_follow_event_depend:5,cu_mempool_attr_used_mem_curr:5,cu_mempool_attr_used_mem_high:5,cu_module_eager_load:5,cu_module_lazy_load:5,cu_occupancy_default:5,cu_occupancy_disable_caching_overrid:5,cu_param_tr_default:5,cu_pointer_attribute_access_flag:5,cu_pointer_attribute_access_flag_non:5,cu_pointer_attribute_access_flag_read:5,cu_pointer_attribute_access_flag_readwrit:5,cu_pointer_attribute_allowed_handle_typ:5,cu_pointer_attribute_buffer_id:5,cu_pointer_attribute_context:5,cu_pointer_attribute_device_ordin:5,cu_pointer_attribute_device_point:5,cu_pointer_attribute_host_point:5,cu_pointer_attribute_is_gpu_direct_rdma_cap:5,cu_pointer_attribute_is_legacy_cuda_ipc_cap:5,cu_pointer_attribute_is_manag:5,cu_pointer_attribute_map:5,cu_pointer_attribute_mapping_base_addr:5,cu_pointer_attribute_mapping_s:5,cu_pointer_attribute_memory_block_id:5,cu_pointer_attribute_memory_typ:5,cu_pointer_attribute_mempool_handl:5,cu_pointer_attribute_p2p_token:5,cu_pointer_attribute_range_s:5,cu_pointer_attribute_range_start_addr:5,cu_pointer_attribute_sync_memop:5,cu_prefer_binari:5,cu_prefer_ptx:5,cu_res_view_format_float_1x16:5,cu_res_view_format_float_1x32:5,cu_res_view_format_float_2x16:5,cu_res_view_format_float_2x32:5,cu_res_view_format_float_4x16:5,cu_res_view_format_float_4x32:5,cu_res_view_format_non:5,cu_res_view_format_signed_bc4:5,cu_res_view_format_signed_bc5:5,cu_res_view_format_signed_bc6h:5,cu_res_view_format_sint_1x16:5,cu_res_view_format_sint_1x32:5,cu_res_view_format_sint_1x8:5,cu_res_view_format_sint_2x16:5,cu_res_view_format_sint_2x32:5,cu_res_view_format_sint_2x8:5,cu_res_view_format_sint_4x16:5,cu_res_view_format_sint_4x32:5,cu_res_view_format_sint_4x8:5,cu_res_view_format_uint_1x16:5,cu_res_view_format_uint_1x32:5,cu_res_view_format_uint_1x8:5,cu_res_view_format_uint_2x16:5,cu_res_view_format_uint_2x32:5,cu_res_view_format_uint_2x8:5,cu_res_view_format_uint_4x16:5,cu_res_view_format_uint_4x32:5,cu_res_view_format_uint_4x8:5,cu_res_view_format_unsigned_bc1:5,cu_res_view_format_unsigned_bc2:5,cu_res_view_format_unsigned_bc3:5,cu_res_view_format_unsigned_bc4:5,cu_res_view_format_unsigned_bc5:5,cu_res_view_format_unsigned_bc6h:5,cu_res_view_format_unsigned_bc7:5,cu_resource_type_arrai:5,cu_resource_type_linear:5,cu_resource_type_mipmapped_arrai:5,cu_resource_type_pitch2d:5,cu_shared_mem_config_default_bank_s:5,cu_shared_mem_config_eight_byte_bank_s:5,cu_shared_mem_config_four_byte_bank_s:5,cu_sharedmem_carveout_default:5,cu_sharedmem_carveout_max_l1:5,cu_sharedmem_carveout_max_shar:5,cu_stream_add_capture_depend:5,cu_stream_attribute_access_policy_window:5,cu_stream_attribute_synchronization_polici:5,cu_stream_capture_mode_glob:5,cu_stream_capture_mode_relax:5,cu_stream_capture_mode_thread_loc:5,cu_stream_capture_status_act:5,cu_stream_capture_status_invalid:5,cu_stream_capture_status_non:5,cu_stream_default:5,cu_stream_legaci:5,cu_stream_mem_op_barri:5,cu_stream_mem_op_flush_remote_writ:[5,6],cu_stream_mem_op_wait_value_32:5,cu_stream_mem_op_wait_value_64:5,cu_stream_mem_op_write_value_32:5,cu_stream_mem_op_write_value_64:5,cu_stream_memory_barrier_type_gpu:5,cu_stream_memory_barrier_type_si:5,cu_stream_non_block:5,cu_stream_per_thread:5,cu_stream_set_capture_depend:5,cu_stream_wait_value_and:5,cu_stream_wait_value_eq:5,cu_stream_wait_value_flush:[5,6],cu_stream_wait_value_geq:5,cu_stream_wait_value_nor:5,cu_stream_write_value_default:5,cu_stream_write_value_no_memory_barri:5,cu_sync_policy_auto:5,cu_sync_policy_blocking_sync:5,cu_sync_policy_spin:5,cu_sync_policy_yield:5,cu_target_compute_20:5,cu_target_compute_21:5,cu_target_compute_30:5,cu_target_compute_32:5,cu_target_compute_35:5,cu_target_compute_37:5,cu_target_compute_50:5,cu_target_compute_52:5,cu_target_compute_53:5,cu_target_compute_60:5,cu_target_compute_61:5,cu_target_compute_62:5,cu_target_compute_70:5,cu_target_compute_72:5,cu_target_compute_75:5,cu_target_compute_80:5,cu_target_compute_86:5,cu_target_compute_87:5,cu_target_compute_89:5,cu_target_compute_90:5,cu_tr_address_mode_bord:5,cu_tr_address_mode_clamp:5,cu_tr_address_mode_mirror:5,cu_tr_address_mode_wrap:5,cu_tr_filter_mode_linear:5,cu_tr_filter_mode_point:5,cu_trsa_override_format:5,cu_trsf_disable_trilinear_optim:5,cu_trsf_normalized_coordin:5,cu_trsf_read_as_integ:5,cu_trsf_seamless_cubemap:5,cu_trsf_srgb:5,cu_user_object_no_destructor_sync:5,cuaccesspolicywindow:5,cuaccesspolicywindow_st:5,cuaccesspolicywindow_v1:5,cuaccessproperti:[5,6],cuaddress_mod:5,cuarrai:[5,6],cuarray3dcr:[5,6],cuarray3dgetdescriptor:[5,6],cuarray_cubemap_fac:5,cuarray_format:5,cuarraycr:[5,6],cuarraydestroi:[5,6],cuarraygetdescriptor:[5,6],cuarraygetmemoryrequir:5,cuarraygetplan:[5,6],cuarraygetsparseproperti:5,cuarraymapinfo:5,cuarraymapinfo_st:5,cuarraymapinfo_v1:5,cuarraysparsesubresourcetyp:5,cuarraysparsesubresourcetype_enum:5,cube:[5,6],cubemap:[5,6],cubin:[5,7],cubinout:5,cubinsizeret:7,cuclusterschedulingpolici:5,cucomputemod:5,cucontext:[5,6],cuctx_flag:5,cuctxcreat:[5,9],cuctxcreate_v3:5,cuctxdestroi:[5,6,9],cuctxdisablepeeraccess:[5,6],cuctxenablepeeraccess:[5,6],cuctxgetapivers:[5,6],cuctxgetcacheconfig:[5,6],cuctxgetcurr:[5,6],cuctxgetdevic:5,cuctxgetexecaffin:5,cuctxgetflag:[5,6],cuctxgetlimit:[5,6],cuctxgetsharedmemconfig:[5,6],cuctxgetstreampriorityrang:[5,6],cuctxpopcurr:5,cuctxpushcurr:5,cuctxresetpersistingl2cach:5,cuctxsetcacheconfig:[5,6],cuctxsetcurr:[5,6],cuctxsetlimit:[5,6],cuctxsetsharedmemconfig:[5,6],cuctxsynchron:[5,6],cuda:[1,2,4,7,10],cuda_api_per_thread_default_stream:[5,6],cuda_array3d_2darrai:5,cuda_array3d_color_attach:5,cuda_array3d_cubemap:5,cuda_array3d_deferred_map:5,cuda_array3d_depth_textur:5,cuda_array3d_descriptor:5,cuda_array3d_descriptor_st:5,cuda_array3d_descriptor_v2:5,cuda_array3d_lay:5,cuda_array3d_spars:5,cuda_array3d_surface_ldst:5,cuda_array3d_texture_gath:5,cuda_array_descriptor:5,cuda_array_descriptor_st:5,cuda_array_descriptor_v2:5,cuda_array_memory_requir:5,cuda_array_memory_requirements_st:5,cuda_array_memory_requirements_v1:5,cuda_array_sparse_properti:5,cuda_array_sparse_properties_st:5,cuda_array_sparse_properties_v1:5,cuda_batch_mem_op_node_param:5,cuda_batch_mem_op_node_params_st:5,cuda_cooperative_launch_multi_device_no_post_launch_sync:5,cuda_cooperative_launch_multi_device_no_pre_launch_sync:5,cuda_egl:[5,6],cuda_egl_infinite_timeout:5,cuda_egl_max_plan:6,cuda_error_already_acquir:5,cuda_error_already_map:5,cuda_error_array_is_map:5,cuda_error_assert:5,cuda_error_captured_ev:5,cuda_error_compat_not_supported_on_devic:5,cuda_error_context_already_curr:5,cuda_error_context_already_in_us:5,cuda_error_context_is_destroi:5,cuda_error_cooperative_launch_too_larg:5,cuda_error_deiniti:5,cuda_error_device_not_licens:5,cuda_error_device_unavail:5,cuda_error_ecc_uncorrect:5,cuda_error_external_devic:5,cuda_error_file_not_found:5,cuda_error_graph_exec_update_failur:5,cuda_error_hardware_stack_error:5,cuda_error_host_memory_already_regist:5,cuda_error_host_memory_not_regist:5,cuda_error_illegal_address:5,cuda_error_illegal_instruct:5,cuda_error_illegal_st:5,cuda_error_invalid_address_spac:5,cuda_error_invalid_cluster_s:5,cuda_error_invalid_context:5,cuda_error_invalid_devic:5,cuda_error_invalid_graphics_context:5,cuda_error_invalid_handl:5,cuda_error_invalid_imag:5,cuda_error_invalid_pc:5,cuda_error_invalid_ptx:5,cuda_error_invalid_sourc:5,cuda_error_invalid_valu:[5,6],cuda_error_jit_compilation_dis:5,cuda_error_jit_compiler_not_found:5,cuda_error_launch_fail:5,cuda_error_launch_incompatible_textur:5,cuda_error_launch_out_of_resourc:5,cuda_error_launch_timeout:5,cuda_error_map_fail:5,cuda_error_misaligned_address:5,cuda_error_mps_client_termin:5,cuda_error_mps_connection_fail:5,cuda_error_mps_max_clients_reach:5,cuda_error_mps_max_connections_reach:5,cuda_error_mps_rpc_failur:5,cuda_error_mps_server_not_readi:5,cuda_error_no_binary_for_gpu:5,cuda_error_no_devic:5,cuda_error_not_found:5,cuda_error_not_initi:[5,6],cuda_error_not_map:5,cuda_error_not_mapped_as_arrai:5,cuda_error_not_mapped_as_point:5,cuda_error_not_permit:5,cuda_error_not_readi:5,cuda_error_not_support:5,cuda_error_nvlink_uncorrect:5,cuda_error_operating_system:5,cuda_error_out_of_memori:[5,6],cuda_error_peer_access_already_en:5,cuda_error_peer_access_not_en:5,cuda_error_peer_access_unsupport:5,cuda_error_primary_context_act:5,cuda_error_profiler_already_start:5,cuda_error_profiler_already_stop:5,cuda_error_profiler_dis:5,cuda_error_profiler_not_initi:5,cuda_error_shared_object_init_fail:5,cuda_error_shared_object_symbol_not_found:5,cuda_error_stream_capture_implicit:5,cuda_error_stream_capture_invalid:5,cuda_error_stream_capture_isol:5,cuda_error_stream_capture_merg:5,cuda_error_stream_capture_unjoin:5,cuda_error_stream_capture_unmatch:5,cuda_error_stream_capture_unsupport:5,cuda_error_stream_capture_wrong_thread:5,cuda_error_stub_librari:5,cuda_error_system_driver_mismatch:5,cuda_error_system_not_readi:5,cuda_error_timeout:5,cuda_error_too_many_p:5,cuda_error_unknown:5,cuda_error_unmap_fail:5,cuda_error_unsupported_exec_affin:5,cuda_error_unsupported_limit:5,cuda_error_unsupported_ptx_vers:5,cuda_ext_sem_signal_node_param:5,cuda_ext_sem_signal_node_params_st:5,cuda_ext_sem_signal_node_params_v1:5,cuda_ext_sem_wait_node_param:5,cuda_ext_sem_wait_node_params_st:5,cuda_ext_sem_wait_node_params_v1:5,cuda_external_memory_buffer_desc:5,cuda_external_memory_buffer_desc_st:5,cuda_external_memory_buffer_desc_v1:5,cuda_external_memory_ded:5,cuda_external_memory_handle_desc:5,cuda_external_memory_handle_desc_st:5,cuda_external_memory_handle_desc_v1:5,cuda_external_memory_mipmapped_array_desc:5,cuda_external_memory_mipmapped_array_desc_st:5,cuda_external_memory_mipmapped_array_desc_v1:5,cuda_external_semaphore_handle_desc:5,cuda_external_semaphore_handle_desc_st:5,cuda_external_semaphore_handle_desc_v1:5,cuda_external_semaphore_param:5,cuda_external_semaphore_signal_param:5,cuda_external_semaphore_signal_params_st:5,cuda_external_semaphore_signal_params_v1:5,cuda_external_semaphore_signal_skip_nvscibuf_memsync:5,cuda_external_semaphore_wait_param:5,cuda_external_semaphore_wait_params_st:5,cuda_external_semaphore_wait_params_v1:5,cuda_external_semaphore_wait_skip_nvscibuf_memsync:5,cuda_graph_instantiate_flag_auto_free_on_launch:5,cuda_graph_instantiate_flag_use_node_prior:5,cuda_hom:[4,16,17],cuda_host_node_param:5,cuda_host_node_params_st:5,cuda_host_node_params_v1:5,cuda_ipc_handle_s:6,cuda_kernel_node_param:5,cuda_kernel_node_params_st:5,cuda_kernel_node_params_v1:5,cuda_launch_param:5,cuda_launch_params_st:5,cuda_launch_params_v1:5,cuda_managed_force_device_alloc:[5,6],cuda_mem_alloc_node_param:5,cuda_mem_alloc_node_params_st:5,cuda_memcpy2d:5,cuda_memcpy2d_st:5,cuda_memcpy2d_v2:5,cuda_memcpy3d:5,cuda_memcpy3d_p:5,cuda_memcpy3d_peer_st:5,cuda_memcpy3d_peer_v1:5,cuda_memcpy3d_st:5,cuda_memcpy3d_v2:5,cuda_memset_node_param:5,cuda_memset_node_params_st:5,cuda_memset_node_params_v1:5,cuda_module_load:5,cuda_nvscisync_attr_sign:5,cuda_nvscisync_attr_wait:5,cuda_pointer_attribute_access_flag:5,cuda_pointer_attribute_p2p_token:5,cuda_pointer_attribute_p2p_tokens_st:5,cuda_pointer_attribute_p2p_tokens_v1:5,cuda_python_cuda_per_thread_default_stream:13,cuda_resource_desc:5,cuda_resource_desc_st:5,cuda_resource_desc_v1:5,cuda_resource_view_desc:5,cuda_resource_view_desc_st:5,cuda_resource_view_desc_v1:5,cuda_runtim:16,cuda_success:[5,6,9],cuda_texture_desc:5,cuda_texture_desc_st:5,cuda_texture_desc_v1:5,cuda_vers:5,cuda_visible_devic:[5,6],cudaaccesspolicywindow:6,cudaaccessproperti:6,cudaaccesspropertynorm:6,cudaaccesspropertypersist:6,cudaaccesspropertystream:6,cudaaddressmodebord:6,cudaaddressmodeclamp:6,cudaaddressmodemirror:6,cudaaddressmodewrap:6,cudaarrai:[5,6],cudaarray_const_t:6,cudaarray_t:6,cudaarraycolorattach:6,cudaarraycubemap:6,cudaarraydefault:6,cudaarraydeferredmap:6,cudaarraygetinfo:[5,6],cudaarraygetmemoryrequir:6,cudaarraygetplan:6,cudaarraygetsparseproperti:6,cudaarraylay:6,cudaarraymemoryrequir:6,cudaarrayspars:6,cudaarraysparseproperti:6,cudaarraysparsepropertiessinglemiptail:6,cudaarraysurfaceloadstor:6,cudaarraytexturegath:6,cudabindsurfacetoarrai:[11,12],cudabindtextur:[11,12],cudabindtexture2d:[11,12],cudabindtexturetoarrai:[11,12],cudabindtexturetomipmappedarrai:[11,12],cudaboundarymodeclamp:6,cudaboundarymodetrap:6,cudaboundarymodezero:6,cudacc_rtc_int128:7,cudacgscop:6,cudacgscopegrid:6,cudacgscopeinvalid:6,cudacgscopemultigrid:6,cudachannelformatdesc:6,cudachannelformatkind:6,cudachannelformatkindfloat:6,cudachannelformatkindnon:6,cudachannelformatkindnv12:6,cudachannelformatkindsign:6,cudachannelformatkindsignedblockcompressed4:6,cudachannelformatkindsignedblockcompressed5:6,cudachannelformatkindsignedblockcompressed6h:6,cudachannelformatkindsignednormalized16x1:6,cudachannelformatkindsignednormalized16x2:6,cudachannelformatkindsignednormalized16x4:6,cudachannelformatkindsignednormalized8x1:6,cudachannelformatkindsignednormalized8x2:6,cudachannelformatkindsignednormalized8x4:6,cudachannelformatkindunsign:6,cudachannelformatkindunsignedblockcompressed1:6,cudachannelformatkindunsignedblockcompressed1srgb:6,cudachannelformatkindunsignedblockcompressed2:6,cudachannelformatkindunsignedblockcompressed2srgb:6,cudachannelformatkindunsignedblockcompressed3:6,cudachannelformatkindunsignedblockcompressed3srgb:6,cudachannelformatkindunsignedblockcompressed4:6,cudachannelformatkindunsignedblockcompressed5:6,cudachannelformatkindunsignedblockcompressed6h:6,cudachannelformatkindunsignedblockcompressed7:6,cudachannelformatkindunsignedblockcompressed7srgb:6,cudachannelformatkindunsignednormalized16x1:6,cudachannelformatkindunsignednormalized16x2:6,cudachannelformatkindunsignednormalized16x4:6,cudachannelformatkindunsignednormalized8x1:6,cudachannelformatkindunsignednormalized8x2:6,cudachannelformatkindunsignednormalized8x4:6,cudachoosedevic:6,cudaclusterschedulingpolici:[5,6],cudaclusterschedulingpolicydefault:6,cudaclusterschedulingpolicyloadbalanc:6,cudaclusterschedulingpolicyspread:6,cudacomputemod:6,cudacomputemodedefault:6,cudacomputemodeexclus:6,cudacomputemodeexclusiveprocess:6,cudacomputemodeprohibit:6,cudaconfigurecal:6,cudacooperativelaunchmultidevicenopostsync:6,cudacooperativelaunchmultidevicenopresync:6,cudacpudeviceid:6,cudacreatechanneldesc:6,cudacreatesurfaceobject:[5,6],cudacreatetextureobject:[5,6],cudacreatetextureobject_v2:6,cudacsv:6,cudactxcanaccessp:6,cudactxdisablepeeraccess:6,cudactxenablepeeraccess:6,cudactxresetpersistingl2cach:6,cudad3d10setdirect3ddevic:6,cudad3d11setdirect3ddevic:6,cudad3d9setdirect3ddevic:6,cudadestroyexternalmemori:6,cudadestroyexternalsemaphor:6,cudadestroysurfaceobject:[5,6],cudadestroytextureobject:[5,6],cudadevattrasyncenginecount:6,cudadevattrcanflushremotewrit:6,cudadevattrcanmaphostmemori:6,cudadevattrcanusehostpointerforregisteredmem:6,cudadevattrclockr:6,cudadevattrclusterlaunch:6,cudadevattrcomputecapabilitymajor:6,cudadevattrcomputecapabilityminor:6,cudadevattrcomputemod:6,cudadevattrcomputepreemptionsupport:6,cudadevattrconcurrentkernel:6,cudadevattrconcurrentmanagedaccess:6,cudadevattrcooperativelaunch:6,cudadevattrcooperativemultidevicelaunch:6,cudadevattrdeferredmappingcudaarraysupport:6,cudadevattrdirectmanagedmemaccessfromhost:6,cudadevattreccen:6,cudadevattrgloball1cachesupport:6,cudadevattrglobalmemorybuswidth:6,cudadevattrgpudirectrdmaflushwritesopt:6,cudadevattrgpudirectrdmasupport:6,cudadevattrgpudirectrdmawritesord:6,cudadevattrgpuoverlap:6,cudadevattrhostnativeatomicsupport:6,cudadevattrhostregisterreadonlysupport:6,cudadevattrhostregistersupport:6,cudadevattrintegr:6,cudadevattrismultigpuboard:6,cudadevattrkernelexectimeout:6,cudadevattrl2caches:6,cudadevattrlocall1cachesupport:6,cudadevattrmanagedmemori:6,cudadevattrmax:6,cudadevattrmaxaccesspolicywindows:6,cudadevattrmaxblockdimi:6,cudadevattrmaxblockdimx:6,cudadevattrmaxblockdimz:6,cudadevattrmaxblockspermultiprocessor:6,cudadevattrmaxgriddimi:6,cudadevattrmaxgriddimx:6,cudadevattrmaxgriddimz:6,cudadevattrmaxpersistingl2caches:6,cudadevattrmaxpitch:6,cudadevattrmaxregistersperblock:6,cudadevattrmaxregisterspermultiprocessor:6,cudadevattrmaxsharedmemoryperblock:6,cudadevattrmaxsharedmemoryperblockoptin:6,cudadevattrmaxsharedmemorypermultiprocessor:6,cudadevattrmaxsurface1dlayeredlay:6,cudadevattrmaxsurface1dlayeredwidth:6,cudadevattrmaxsurface1dwidth:6,cudadevattrmaxsurface2dheight:6,cudadevattrmaxsurface2dlayeredheight:6,cudadevattrmaxsurface2dlayeredlay:6,cudadevattrmaxsurface2dlayeredwidth:6,cudadevattrmaxsurface2dwidth:6,cudadevattrmaxsurface3ddepth:6,cudadevattrmaxsurface3dheight:6,cudadevattrmaxsurface3dwidth:6,cudadevattrmaxsurfacecubemaplayeredlay:6,cudadevattrmaxsurfacecubemaplayeredwidth:6,cudadevattrmaxsurfacecubemapwidth:6,cudadevattrmaxtexture1dlayeredlay:6,cudadevattrmaxtexture1dlayeredwidth:6,cudadevattrmaxtexture1dlinearwidth:6,cudadevattrmaxtexture1dmipmappedwidth:6,cudadevattrmaxtexture1dwidth:6,cudadevattrmaxtexture2dgatherheight:6,cudadevattrmaxtexture2dgatherwidth:6,cudadevattrmaxtexture2dheight:6,cudadevattrmaxtexture2dlayeredheight:6,cudadevattrmaxtexture2dlayeredlay:6,cudadevattrmaxtexture2dlayeredwidth:6,cudadevattrmaxtexture2dlinearheight:6,cudadevattrmaxtexture2dlinearpitch:6,cudadevattrmaxtexture2dlinearwidth:6,cudadevattrmaxtexture2dmipmappedheight:6,cudadevattrmaxtexture2dmipmappedwidth:6,cudadevattrmaxtexture2dwidth:6,cudadevattrmaxtexture3ddepth:6,cudadevattrmaxtexture3ddepthalt:6,cudadevattrmaxtexture3dheight:6,cudadevattrmaxtexture3dheightalt:6,cudadevattrmaxtexture3dwidth:6,cudadevattrmaxtexture3dwidthalt:6,cudadevattrmaxtexturecubemaplayeredlay:6,cudadevattrmaxtexturecubemaplayeredwidth:6,cudadevattrmaxtexturecubemapwidth:6,cudadevattrmaxthreadsperblock:6,cudadevattrmaxthreadspermultiprocessor:6,cudadevattrmaxtimelinesemaphoreinteropsupport:6,cudadevattrmemoryclockr:6,cudadevattrmemorypoolssupport:6,cudadevattrmemorypoolsupportedhandletyp:6,cudadevattrmultigpuboardgroupid:6,cudadevattrmultiprocessorcount:6,cudadevattrpageablememoryaccess:6,cudadevattrpageablememoryaccessuseshostpaget:6,cudadevattrpcibusid:6,cudadevattrpcideviceid:6,cudadevattrpcidomainid:6,cudadevattrreserved92:6,cudadevattrreserved93:6,cudadevattrreserved94:6,cudadevattrreservedsharedmemoryperblock:6,cudadevattrsingletodoubleprecisionperfratio:6,cudadevattrsparsecudaarraysupport:6,cudadevattrstreamprioritiessupport:6,cudadevattrsurfacealign:6,cudadevattrtccdriv:6,cudadevattrtexturealign:6,cudadevattrtexturepitchalign:6,cudadevattrtimelinesemaphoreinteropsupport:6,cudadevattrtotalconstantmemori:6,cudadevattrunifiedaddress:6,cudadevattrwarps:6,cudadeviceattr:6,cudadeviceattrreadonlyhostregistersupport:6,cudadeviceblockingsync:6,cudadevicecanaccessp:[5,6],cudadevicecount:[5,6],cudadevicedisablepeeraccess:[5,6],cudadeviceenablepeeraccess:[5,6],cudadeviceflushgpudirectrdmawrit:6,cudadevicegetattribut:[5,6],cudadevicegetbypcibusid:[5,6],cudadevicegetcacheconfig:[5,6],cudadevicegetdefaultmempool:6,cudadevicegetgraphmemattribut:6,cudadevicegetlimit:[5,6],cudadevicegetmempool:6,cudadevicegetnvscisyncattribut:6,cudadevicegetp2pattribut:[5,6],cudadevicegetpcibusid:[5,6],cudadevicegetsharedmemconfig:[5,6],cudadevicegetstreampriorityrang:[5,6],cudadevicegettexture1dlinearmaxwidth:[5,6],cudadevicegraphmemtrim:6,cudadevicelmemresizetomax:6,cudadevicemaphost:6,cudadevicemask:6,cudadevicep2pattr:6,cudadeviceprop:6,cudadevicereset:[5,6],cudadevicescheduleauto:6,cudadevicescheduleblockingsync:6,cudadeviceschedulemask:6,cudadeviceschedulespin:6,cudadevicescheduleyield:6,cudadevicesetcacheconfig:[5,6],cudadevicesetgraphmemattribut:6,cudadevicesetlimit:[5,6],cudadevicesetmempool:6,cudadevicesetsharedmemconfig:[5,6],cudadevicesynchron:[5,6],cudadevp2pattraccesssupport:6,cudadevp2pattrcudaarrayaccesssupport:6,cudadevp2pattrnativeatomicsupport:6,cudadevp2pattrperformancerank:6,cudadrivergetvers:[5,6],cudaeglcolorformat:6,cudaeglcolorformata:6,cudaeglcolorformatabgr:6,cudaeglcolorformatargb:6,cudaeglcolorformatayuv:6,cudaeglcolorformatayuv_:6,cudaeglcolorformatbayer10bggr:6,cudaeglcolorformatbayer10cccc:6,cudaeglcolorformatbayer10gbrg:6,cudaeglcolorformatbayer10grbg:6,cudaeglcolorformatbayer10rggb:6,cudaeglcolorformatbayer12bccr:6,cudaeglcolorformatbayer12bggr:6,cudaeglcolorformatbayer12cbrc:6,cudaeglcolorformatbayer12cccc:6,cudaeglcolorformatbayer12crbc:6,cudaeglcolorformatbayer12gbrg:6,cudaeglcolorformatbayer12grbg:6,cudaeglcolorformatbayer12rccb:6,cudaeglcolorformatbayer12rggb:6,cudaeglcolorformatbayer14bggr:6,cudaeglcolorformatbayer14gbrg:6,cudaeglcolorformatbayer14grbg:6,cudaeglcolorformatbayer14rggb:6,cudaeglcolorformatbayer20bggr:6,cudaeglcolorformatbayer20gbrg:6,cudaeglcolorformatbayer20grbg:6,cudaeglcolorformatbayer20rggb:6,cudaeglcolorformatbayerbccr:6,cudaeglcolorformatbayerbggr:6,cudaeglcolorformatbayercbrc:6,cudaeglcolorformatbayercrbc:6,cudaeglcolorformatbayergbrg:6,cudaeglcolorformatbayergrbg:6,cudaeglcolorformatbayerispbggr:6,cudaeglcolorformatbayerispgbrg:6,cudaeglcolorformatbayerispgrbg:6,cudaeglcolorformatbayerisprggb:6,cudaeglcolorformatbayerrccb:6,cudaeglcolorformatbayerrggb:6,cudaeglcolorformatbgra:6,cudaeglcolorformati:6,cudaeglcolorformatl:6,cudaeglcolorformatr:6,cudaeglcolorformatrg:6,cudaeglcolorformatrgba:6,cudaeglcolorformatuyvy422:6,cudaeglcolorformatuyvy_:6,cudaeglcolorformatvyui:6,cudaeglcolorformatvyuy_:6,cudaeglcolorformaty10_709_:6,cudaeglcolorformaty10_:6,cudaeglcolorformaty10v10u10_420semiplanar:6,cudaeglcolorformaty10v10u10_420semiplanar_2020:6,cudaeglcolorformaty10v10u10_420semiplanar_709:6,cudaeglcolorformaty10v10u10_420semiplanar_709_:6,cudaeglcolorformaty10v10u10_420semiplanar_:6,cudaeglcolorformaty10v10u10_422semiplanar:6,cudaeglcolorformaty10v10u10_422semiplanar_2020:6,cudaeglcolorformaty10v10u10_422semiplanar_709:6,cudaeglcolorformaty10v10u10_444semiplanar:6,cudaeglcolorformaty10v10u10_444semiplanar_709_:6,cudaeglcolorformaty10v10u10_444semiplanar_:6,cudaeglcolorformaty12_709_:6,cudaeglcolorformaty12_:6,cudaeglcolorformaty12v12u12_420semiplanar:6,cudaeglcolorformaty12v12u12_420semiplanar_709_:6,cudaeglcolorformaty12v12u12_420semiplanar_:6,cudaeglcolorformaty12v12u12_444semiplanar:6,cudaeglcolorformaty12v12u12_444semiplanar_709_:6,cudaeglcolorformaty12v12u12_444semiplanar_:6,cudaeglcolorformaty_709_:6,cudaeglcolorformaty_:6,cudaeglcolorformatyuv420planar:6,cudaeglcolorformatyuv420planar_2020:6,cudaeglcolorformatyuv420planar_709:6,cudaeglcolorformatyuv420planar_:6,cudaeglcolorformatyuv420semiplanar:6,cudaeglcolorformatyuv420semiplanar_2020:6,cudaeglcolorformatyuv420semiplanar_709:6,cudaeglcolorformatyuv420semiplanar_:6,cudaeglcolorformatyuv422planar:6,cudaeglcolorformatyuv422planar_:6,cudaeglcolorformatyuv422semiplanar:6,cudaeglcolorformatyuv422semiplanar_:6,cudaeglcolorformatyuv444planar:6,cudaeglcolorformatyuv444planar_:6,cudaeglcolorformatyuv444semiplanar:6,cudaeglcolorformatyuv444semiplanar_:6,cudaeglcolorformatyuva:6,cudaeglcolorformatyuva_:6,cudaeglcolorformatyuyv422:6,cudaeglcolorformatyuyv_:6,cudaeglcolorformatyvu420planar:6,cudaeglcolorformatyvu420planar_2020:6,cudaeglcolorformatyvu420planar_709:6,cudaeglcolorformatyvu420planar_:6,cudaeglcolorformatyvu420semiplanar:6,cudaeglcolorformatyvu420semiplanar_2020:6,cudaeglcolorformatyvu420semiplanar_709:6,cudaeglcolorformatyvu420semiplanar_:6,cudaeglcolorformatyvu422planar:6,cudaeglcolorformatyvu422planar_:6,cudaeglcolorformatyvu422semiplanar:6,cudaeglcolorformatyvu422semiplanar_:6,cudaeglcolorformatyvu444planar:6,cudaeglcolorformatyvu444planar_:6,cudaeglcolorformatyvu444semiplanar:6,cudaeglcolorformatyvu444semiplanar_:6,cudaeglcolorformatyvyu:6,cudaeglcolorformatyvyu_:6,cudaeglfram:6,cudaeglframe_st:6,cudaeglframetyp:6,cudaeglframetypearrai:6,cudaeglframetypepitch:6,cudaeglplanedesc:6,cudaeglplanedesc_st:6,cudaeglresourcelocationflag:6,cudaeglresourcelocationsysmem:6,cudaeglresourcelocationvidmem:6,cudaeglstreamconnect:6,cudaeglstreamconsumeracquirefram:[5,6,12],cudaeglstreamconsumerconnect:[5,6,12],cudaeglstreamconsumerconnectwithflag:[5,6,12],cudaeglstreamconsumerdisconnect:[5,6,12],cudaeglstreamconsumerreleasefram:[5,6,12],cudaeglstreamproducerconnect:[5,6,12],cudaeglstreamproducerdisconnect:[5,6,12],cudaeglstreamproducerpresentfram:[5,6,12],cudaeglstreamproducerreturnfram:[5,6,12],cudaenabledefault:6,cudaenablelegacystream:6,cudaenablepeeraccess:6,cudaenableperthreaddefaultstream:6,cudaerror:6,cudaerror_t:[6,13],cudaerroraddressofconst:6,cudaerroralreadyacquir:6,cudaerroralreadymap:6,cudaerrorapifailurebas:6,cudaerrorarrayismap:6,cudaerrorassert:6,cudaerrorcallrequiresnewerdriv:6,cudaerrorcapturedev:6,cudaerrorcompatnotsupportedondevic:6,cudaerrorcontextisdestroi:6,cudaerrorcooperativelaunchtoolarg:6,cudaerrorcudartunload:6,cudaerrordevicealreadyinus:6,cudaerrordevicenotlicens:6,cudaerrordevicesunavail:6,cudaerrordeviceuniniti:6,cudaerrorduplicatesurfacenam:6,cudaerrorduplicatetexturenam:6,cudaerrorduplicatevariablenam:6,cudaerroreccuncorrect:6,cudaerrorexternaldevic:6,cudaerrorfilenotfound:6,cudaerrorgraphexecupdatefailur:6,cudaerrorhardwarestackerror:6,cudaerrorhostmemoryalreadyregist:6,cudaerrorhostmemorynotregist:6,cudaerrorillegaladdress:6,cudaerrorillegalinstruct:6,cudaerrorillegalst:6,cudaerrorincompatibledrivercontext:6,cudaerrorinitializationerror:6,cudaerrorinsufficientdriv:6,cudaerrorinvalidaddressspac:6,cudaerrorinvalidchanneldescriptor:6,cudaerrorinvalidclusters:6,cudaerrorinvalidconfigur:6,cudaerrorinvalidcontext:6,cudaerrorinvaliddevic:6,cudaerrorinvaliddevicefunct:6,cudaerrorinvaliddevicepoint:6,cudaerrorinvalidfilterset:6,cudaerrorinvalidgraphicscontext:6,cudaerrorinvalidhandl:6,cudaerrorinvalidhostpoint:6,cudaerrorinvalidkernelimag:6,cudaerrorinvalidmemcpydirect:6,cudaerrorinvalidnormset:6,cudaerrorinvalidpc:6,cudaerrorinvalidpitchvalu:6,cudaerrorinvalidptx:6,cudaerrorinvalidresourcehandl:6,cudaerrorinvalidsourc:6,cudaerrorinvalidsurfac:6,cudaerrorinvalidsymbol:6,cudaerrorinvalidtextur:6,cudaerrorinvalidtexturebind:6,cudaerrorinvalidvalu:6,cudaerrorjitcompilationdis:6,cudaerrorjitcompilernotfound:6,cudaerrorlaunchfailur:6,cudaerrorlaunchfilescopedsurf:6,cudaerrorlaunchfilescopedtex:6,cudaerrorlaunchincompatibletextur:6,cudaerrorlaunchmaxdepthexceed:6,cudaerrorlaunchoutofresourc:6,cudaerrorlaunchpendingcountexceed:[5,6],cudaerrorlaunchtimeout:6,cudaerrormapbufferobjectfail:6,cudaerrormemoryalloc:6,cudaerrormemoryvaluetoolarg:6,cudaerrormisalignedaddress:6,cudaerrormissingconfigur:6,cudaerrormixeddeviceexecut:6,cudaerrormpsclienttermin:6,cudaerrormpsconnectionfail:6,cudaerrormpsmaxclientsreach:6,cudaerrormpsmaxconnectionsreach:6,cudaerrormpsrpcfailur:6,cudaerrormpsservernotreadi:6,cudaerrornodevic:6,cudaerrornokernelimagefordevic:6,cudaerrornotmap:6,cudaerrornotmappedasarrai:6,cudaerrornotmappedaspoint:6,cudaerrornotpermit:6,cudaerrornotreadi:6,cudaerrornotsupport:6,cudaerrornotyetimpl:6,cudaerrornvlinkuncorrect:6,cudaerroroperatingsystem:6,cudaerroroutofmemori:6,cudaerrorpeeraccessalreadyen:6,cudaerrorpeeraccessnoten:6,cudaerrorpeeraccessunsupport:6,cudaerrorpriorlaunchfailur:6,cudaerrorprofileralreadystart:6,cudaerrorprofileralreadystop:6,cudaerrorprofilerdis:6,cudaerrorprofilernotiniti:6,cudaerrorsetonactiveprocess:6,cudaerrorsharedobjectinitfail:6,cudaerrorsharedobjectsymbolnotfound:6,cudaerrorsoftwarevaliditynotestablish:6,cudaerrorstartupfailur:6,cudaerrorstreamcaptureimplicit:6,cudaerrorstreamcaptureinvalid:6,cudaerrorstreamcaptureisol:6,cudaerrorstreamcapturemerg:6,cudaerrorstreamcaptureunjoin:6,cudaerrorstreamcaptureunmatch:6,cudaerrorstreamcaptureunsupport:6,cudaerrorstreamcapturewrongthread:6,cudaerrorstublibrari:6,cudaerrorsymbolnotfound:6,cudaerrorsyncdepthexceed:[5,6],cudaerrorsynchronizationerror:6,cudaerrorsystemdrivermismatch:6,cudaerrorsystemnotreadi:6,cudaerrortexturefetchfail:6,cudaerrortexturenotbound:6,cudaerrortimeout:6,cudaerrortoomanyp:6,cudaerrorunknown:6,cudaerrorunmapbufferobjectfail:6,cudaerrorunsupportedexecaffin:6,cudaerrorunsupportedlimit:6,cudaerrorunsupportedptxvers:6,cudaerrorvalu:6,cudaevent_t:[5,6],cudaeventblockingsync:6,cudaeventcr:[5,6],cudaeventcreatefromeglsync:[6,12],cudaeventcreatewithflag:[5,6],cudaeventdefault:6,cudaeventdestroi:[5,6],cudaeventdisabletim:6,cudaeventelapsedtim:[5,6],cudaeventinterprocess:6,cudaeventqueri:[5,6],cudaeventrecord:[5,6],cudaeventrecorddefault:6,cudaeventrecordextern:6,cudaeventrecordwithflag:6,cudaeventsynchron:[5,6],cudaeventwaitdefault:6,cudaeventwaitextern:6,cudaext:6,cudaexternalmemory_t:6,cudaexternalmemorybufferdesc:6,cudaexternalmemoryded:6,cudaexternalmemorygetmappedbuff:6,cudaexternalmemorygetmappedmipmappedarrai:6,cudaexternalmemoryhandledesc:6,cudaexternalmemoryhandletyp:6,cudaexternalmemoryhandletyped3d11resourc:6,cudaexternalmemoryhandletyped3d11resourcekmt:6,cudaexternalmemoryhandletyped3d12heap:6,cudaexternalmemoryhandletyped3d12resourc:6,cudaexternalmemoryhandletypenvscibuf:6,cudaexternalmemoryhandletypeopaquefd:6,cudaexternalmemoryhandletypeopaquewin32:6,cudaexternalmemoryhandletypeopaquewin32kmt:6,cudaexternalmemorymipmappedarraydesc:6,cudaexternalsemaphore_t:6,cudaexternalsemaphorehandledesc:6,cudaexternalsemaphorehandletyp:6,cudaexternalsemaphorehandletyped3d11f:6,cudaexternalsemaphorehandletyped3d12f:6,cudaexternalsemaphorehandletypekeyedmutex:6,cudaexternalsemaphorehandletypekeyedmutexkmt:6,cudaexternalsemaphorehandletypenvscisync:6,cudaexternalsemaphorehandletypeopaquefd:6,cudaexternalsemaphorehandletypeopaquewin32:6,cudaexternalsemaphorehandletypeopaquewin32kmt:6,cudaexternalsemaphorehandletypetimelinesemaphorefd:6,cudaexternalsemaphorehandletypetimelinesemaphorewin32:6,cudaexternalsemaphoresignalnodeparam:6,cudaexternalsemaphoresignalparam:6,cudaexternalsemaphoresignalskipnvscibufmemsync:6,cudaexternalsemaphorewaitnodeparam:6,cudaexternalsemaphorewaitparam:6,cudaexternalsemaphorewaitskipnvscibufmemsync:6,cudafiltermodelinear:6,cudafiltermodepoint:6,cudaflushgpudirectrdmawrit:6,cudaflushgpudirectrdmawritesopt:6,cudaflushgpudirectrdmawritesoptionhost:6,cudaflushgpudirectrdmawritesoptionmemop:6,cudaflushgpudirectrdmawritesscop:6,cudaflushgpudirectrdmawritestarget:6,cudaflushgpudirectrdmawritestargetcurrentdevic:6,cudaflushgpudirectrdmawritestoalldevic:6,cudaflushgpudirectrdmawritestoown:6,cudaformatmodeauto:6,cudaformatmodeforc:6,cudafre:[5,6],cudafreearrai:[5,6],cudafreeasync:6,cudafreehost:[5,6],cudafreemipmappedarrai:[5,6],cudafuncattribut:6,cudafuncattributeclusterdimmustbeset:6,cudafuncattributeclusterschedulingpolicyprefer:6,cudafuncattributemax:6,cudafuncattributemaxdynamicsharedmemorys:6,cudafuncattributenonportableclustersizeallow:6,cudafuncattributepreferredsharedmemorycarveout:6,cudafuncattributerequiredclusterdepth:6,cudafuncattributerequiredclusterheight:6,cudafuncattributerequiredclusterwidth:6,cudafunccach:6,cudafunccachepreferequ:6,cudafunccachepreferl1:6,cudafunccacheprefernon:6,cudafunccacheprefershar:6,cudafuncgetattribut:[5,6],cudafuncsetattribut:[5,6],cudafuncsetcacheconfig:[5,6],cudafuncsetsharedmemconfig:[5,6],cudafunction_t:6,cudagetarrayplan:5,cudagetchanneldesc:6,cudagetdevic:[5,6],cudagetdevicecount:[5,6],cudagetdeviceflag:[5,6],cudagetdeviceproperti:[5,6],cudagetdriverentrypoint:[5,6],cudagetdriverentrypointflag:6,cudageterrornam:[5,6],cudageterrorstr:[5,6],cudagetfuncbysymbol:[11,12,13,14,15,16,17,18],cudagetlasterror:[5,6],cudagetmipmappedarraylevel:[5,6],cudagetsurfaceobjectresourcedesc:[5,6],cudagetsurfacerefer:[5,11,12],cudagetsymboladdress:[5,11,12,13,14,15,16,17,18],cudagetsymbols:[5,11,12,13,14,15,16,17,18],cudagettexturealignmentoffset:[6,11,12],cudagettextureobjectresourcedesc:[5,6],cudagettextureobjectresourceviewdesc:[5,6],cudagettextureobjecttexturedesc:[5,6],cudagettextureobjecttexturedesc_v2:6,cudagettexturerefer:[5,11,12],cudagldevicelist:6,cudagldevicelistal:6,cudagldevicelistcurrentfram:6,cudagldevicelistnextfram:6,cudaglgetdevic:[5,6,12],cudaglmapbufferobject:12,cudaglmapbufferobjectasync:12,cudaglregisterbufferobject:12,cudaglsetbufferobjectmapflag:12,cudaglsetgldevic:[6,12],cudaglunmapbufferobject:12,cudaglunmapbufferobjectasync:12,cudaglunregisterbufferobject:12,cudagpudirectrdmawritesord:6,cudagpudirectrdmawritesorderingalldevic:6,cudagpudirectrdmawritesorderingnon:6,cudagpudirectrdmawritesorderingown:6,cudagraph_t:[5,6],cudagraphaddchildgraphnod:6,cudagraphadddepend:6,cudagraphaddemptynod:6,cudagraphaddeventrecordnod:6,cudagraphaddeventwaitnod:6,cudagraphaddexternalsemaphoressignalnod:6,cudagraphaddexternalsemaphoreswaitnod:6,cudagraphaddhostnod:6,cudagraphaddkernelnod:6,cudagraphaddmemallocnod:6,cudagraphaddmemcpynod:6,cudagraphaddmemcpynode1d:6,cudagraphaddmemcpynodefromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphaddmemcpynodetosymbol:[6,11,12,13,14,15,16,17,18],cudagraphaddmemfreenod:6,cudagraphaddmemsetnod:6,cudagraphchildgraphnodegetgraph:6,cudagraphclon:6,cudagraphcr:6,cudagraphdebugdotflag:6,cudagraphdebugdotflagseventnodeparam:6,cudagraphdebugdotflagsextsemassignalnodeparam:6,cudagraphdebugdotflagsextsemaswaitnodeparam:6,cudagraphdebugdotflagshandl:6,cudagraphdebugdotflagshostnodeparam:6,cudagraphdebugdotflagskernelnodeattribut:6,cudagraphdebugdotflagskernelnodeparam:6,cudagraphdebugdotflagsmemcpynodeparam:6,cudagraphdebugdotflagsmemsetnodeparam:6,cudagraphdebugdotflagsverbos:6,cudagraphdebugdotprint:6,cudagraphdestroi:6,cudagraphdestroynod:6,cudagrapheventrecordnodegetev:6,cudagrapheventrecordnodesetev:6,cudagrapheventwaitnodegetev:6,cudagrapheventwaitnodesetev:6,cudagraphexec_t:[5,6],cudagraphexecchildgraphnodesetparam:6,cudagraphexecdestroi:6,cudagraphexeceventrecordnodesetev:6,cudagraphexeceventwaitnodesetev:6,cudagraphexecexternalsemaphoressignalnodesetparam:6,cudagraphexecexternalsemaphoreswaitnodesetparam:6,cudagraphexechostnodesetparam:6,cudagraphexeckernelnodesetparam:6,cudagraphexecmemcpynodesetparam:6,cudagraphexecmemcpynodesetparams1d:6,cudagraphexecmemcpynodesetparamsfromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphexecmemcpynodesetparamstosymbol:[6,11,12,13,14,15,16,17,18],cudagraphexecmemsetnodesetparam:6,cudagraphexecupd:6,cudagraphexecupdateerror:6,cudagraphexecupdateerrorattributeschang:6,cudagraphexecupdateerrorfunctionchang:6,cudagraphexecupdateerrornodetypechang:6,cudagraphexecupdateerrornotsupport:6,cudagraphexecupdateerrorparameterschang:6,cudagraphexecupdateerrortopologychang:6,cudagraphexecupdateerrorunsupportedfunctionchang:6,cudagraphexecupdateresult:6,cudagraphexecupdatesuccess:6,cudagraphexternalsemaphoressignalnodegetparam:6,cudagraphexternalsemaphoressignalnodesetparam:6,cudagraphexternalsemaphoreswaitnodegetparam:6,cudagraphexternalsemaphoreswaitnodesetparam:6,cudagraphgetedg:6,cudagraphgetnod:6,cudagraphgetrootnod:6,cudagraphhostnodegetparam:6,cudagraphhostnodesetparam:6,cudagraphicscubefac:6,cudagraphicscubefacenegativei:6,cudagraphicscubefacenegativex:6,cudagraphicscubefacenegativez:6,cudagraphicscubefacepositivei:6,cudagraphicscubefacepositivex:6,cudagraphicscubefacepositivez:6,cudagraphicsd3d10registerresourc:6,cudagraphicsd3d11registerresourc:6,cudagraphicsd3d9registerresourc:6,cudagraphicseglregisterimag:[5,6,12],cudagraphicsglregisterbuff:[5,6,12],cudagraphicsglregisterimag:[5,6,12],cudagraphicsmapflag:6,cudagraphicsmapflagsnon:6,cudagraphicsmapflagsreadonli:6,cudagraphicsmapflagswritediscard:6,cudagraphicsmapresourc:[5,6],cudagraphicsregisterflag:6,cudagraphicsregisterflagsnon:6,cudagraphicsregisterflagsreadonli:6,cudagraphicsregisterflagssurfaceloadstor:6,cudagraphicsregisterflagstexturegath:6,cudagraphicsregisterflagswritediscard:6,cudagraphicsresourc:6,cudagraphicsresource_t:6,cudagraphicsresourcegetmappedeglfram:[6,12],cudagraphicsresourcegetmappedmipmappedarrai:[5,6],cudagraphicsresourcegetmappedpoint:6,cudagraphicsresourcesetmapflag:[5,6],cudagraphicssubresourcegetmappedarrai:[5,6],cudagraphicsunmapresourc:[5,6],cudagraphicsunregisterresourc:[5,6],cudagraphicsvdpauregisteroutputsurfac:[5,6,12],cudagraphicsvdpauregistervideosurfac:[5,6,12],cudagraphinstanti:6,cudagraphinstantiateflag:6,cudagraphinstantiateflagautofreeonlaunch:6,cudagraphinstantiateflagusenodeprior:6,cudagraphinstantiatewithflag:6,cudagraphkernelnodecopyattribut:6,cudagraphkernelnodegetattribut:6,cudagraphkernelnodegetparam:6,cudagraphkernelnodesetattribut:6,cudagraphkernelnodesetparam:6,cudagraphlaunch:6,cudagraphmemallocnodegetparam:6,cudagraphmemattributetyp:6,cudagraphmemattrreservedmemcurr:6,cudagraphmemattrreservedmemhigh:6,cudagraphmemattrusedmemcurr:6,cudagraphmemattrusedmemhigh:6,cudagraphmemcpynodegetparam:6,cudagraphmemcpynodesetparam:6,cudagraphmemcpynodesetparams1d:6,cudagraphmemcpynodesetparamsfromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphmemcpynodesetparamstosymbol:[6,11,12,13,14,15,16,17,18],cudagraphmemfreenodegetparam:6,cudagraphmemsetnodegetparam:6,cudagraphmemsetnodesetparam:6,cudagraphnode_t:[5,6],cudagraphnodefindinclon:6,cudagraphnodegetdepend:6,cudagraphnodegetdependentnod:6,cudagraphnodegeten:6,cudagraphnodegettyp:6,cudagraphnodeseten:6,cudagraphnodetyp:6,cudagraphnodetypecount:6,cudagraphnodetypeempti:6,cudagraphnodetypeeventrecord:6,cudagraphnodetypeextsemaphoresign:6,cudagraphnodetypeextsemaphorewait:6,cudagraphnodetypegraph:6,cudagraphnodetypehost:6,cudagraphnodetypekernel:6,cudagraphnodetypememalloc:6,cudagraphnodetypememcpi:6,cudagraphnodetypememfre:6,cudagraphnodetypememset:6,cudagraphnodetypewaitev:6,cudagraphreleaseuserobject:6,cudagraphremovedepend:6,cudagraphretainuserobject:6,cudagraphupload:6,cudagraphuserobjectmov:6,cudahostalloc:[5,6],cudahostallocdefault:6,cudahostallocmap:6,cudahostallocport:6,cudahostallocwritecombin:6,cudahostfn_t:6,cudahostgetdevicepoint:[5,6],cudahostgetflag:[5,6],cudahostnodeparam:6,cudahostregist:[5,6],cudahostregisterdefault:6,cudahostregisteriomemori:6,cudahostregistermap:6,cudahostregisterport:6,cudahostregisterreadonli:6,cudahostunregist:[5,6],cudaimportexternalmemori:6,cudaimportexternalsemaphor:6,cudainvaliddeviceid:6,cudaipcclosememhandl:[5,6],cudaipceventhandl:6,cudaipceventhandle_st:6,cudaipceventhandle_t:6,cudaipcgeteventhandl:[5,6],cudaipcgetmemhandl:[5,6],cudaipcmemhandl:6,cudaipcmemhandle_st:6,cudaipcmemhandle_t:6,cudaipcmemlazyenablepeeraccess:6,cudaipcopeneventhandl:[5,6],cudaipcopenmemhandl:[5,6],cudakernelnodeattributeclusterdimens:6,cudakernelnodeattributeclusterschedulingpolicyprefer:6,cudakernelnodeattrid:6,cudakernelnodeattrvalu:6,cudakernelnodeparam:6,cudakeyvaluepair:6,cudalaunchattribut:6,cudalaunchattribute_st:6,cudalaunchattributeaccesspolicywindow:6,cudalaunchattributeclusterdimens:6,cudalaunchattributeclusterschedulingpolicyprefer:6,cudalaunchattributecoop:6,cudalaunchattributeid:6,cudalaunchattributeignor:6,cudalaunchattributeprior:6,cudalaunchattributeprogrammaticev:6,cudalaunchattributeprogrammaticstreamseri:6,cudalaunchattributesynchronizationpolici:6,cudalaunchattributevalu:6,cudalaunchcooperativekernel:[5,6,11,12,13,14,15,16,17,18],cudalaunchcooperativekernelmultidevic:[5,6,11,12,13,14,15,16,17,18],cudalaunchhostfunc:6,cudalaunchkernel:[5,6,11,12,13,14,15,16,17,18],cudalaunchkernelex:5,cudalimit:6,cudalimitdevruntimependinglaunchcount:6,cudalimitdevruntimesyncdepth:6,cudalimitmallocheaps:6,cudalimitmaxl2fetchgranular:6,cudalimitpersistingl2caches:6,cudalimitprintffifos:6,cudalimitstacks:6,cudamalloc3d:6,cudamalloc3darrai:[5,6],cudamalloc:[5,6],cudamallocarrai:[5,6],cudamallocasync:6,cudamallocfrompoolasync:6,cudamallochost:[5,6],cudamallocmanag:[5,6],cudamallocmipmappedarrai:[5,6],cudamallocpitch:[5,6],cudamaphost:6,cudamemaccessdesc:6,cudamemaccessflag:6,cudamemaccessflagsprotnon:6,cudamemaccessflagsprotread:6,cudamemaccessflagsprotreadwrit:6,cudamemadvicereadmostli:6,cudamemadvicesetaccessedbi:6,cudamemadviceunsetreadmostli:6,cudamemadvis:[5,6],cudamemadvisesetaccessedbi:6,cudamemadvisesetpreferredloc:6,cudamemadvisesetreadmostli:6,cudamemadviseunsetaccessedbi:6,cudamemadviseunsetpreferredloc:6,cudamemadviseunsetreadmostli:6,cudamemallocationhandletyp:6,cudamemallocationtyp:6,cudamemallocationtypeinvalid:6,cudamemallocationtypemax:6,cudamemallocationtypepin:6,cudamemallocnodeparam:6,cudamemattachglob:6,cudamemattachhost:6,cudamemattachsingl:6,cudamemcpi:[5,6],cudamemcpy2d:[5,6],cudamemcpy2darraytoarrai:6,cudamemcpy2dasync:[5,6],cudamemcpy2dfromarrai:[5,6],cudamemcpy2dfromarrayasync:[5,6],cudamemcpy2dtoarrai:[5,6],cudamemcpy2dtoarrayasync:[5,6],cudamemcpy3d:[5,6],cudamemcpy3dasync:[5,6],cudamemcpy3dp:[5,6],cudamemcpy3dparm:6,cudamemcpy3dpeerasync:[5,6],cudamemcpy3dpeerparm:6,cudamemcpyarraytoarrai:5,cudamemcpyasync:[5,6],cudamemcpydefault:6,cudamemcpydevicetodevic:6,cudamemcpydevicetohost:6,cudamemcpyfromarrai:5,cudamemcpyfromarrayasync:5,cudamemcpyfromsymbol:[5,6,11,12,13,14,15,16,17,18],cudamemcpyfromsymbolasync:[5,6,11,12,13,14,15,16,17,18],cudamemcpyhosttodevic:6,cudamemcpyhosttohost:6,cudamemcpykind:6,cudamemcpyp:[5,6],cudamemcpypeerasync:[5,6],cudamemcpytoarrai:5,cudamemcpytoarrayasync:5,cudamemcpytosymbol:[5,6,11,12,13,14,15,16,17,18],cudamemcpytosymbolasync:[5,6,11,12,13,14,15,16,17,18],cudamemfre:6,cudamemfreeasync:6,cudamemgetinfo:[5,6],cudamemhandletypenon:6,cudamemhandletypeposixfiledescriptor:6,cudamemhandletypewin32:6,cudamemhandletypewin32kmt:6,cudamemloc:6,cudamemlocationtyp:6,cudamemlocationtypedevic:6,cudamemlocationtypeinvalid:6,cudamemoryadvis:6,cudamemorytyp:6,cudamemorytypedevic:6,cudamemorytypehost:6,cudamemorytypemanag:6,cudamemorytypeunregist:6,cudamempool:6,cudamempool_t:[5,6],cudamempoolattr:6,cudamempoolattrreleasethreshold:6,cudamempoolattrreservedmemcurr:6,cudamempoolattrreservedmemhigh:6,cudamempoolattrusedmemcurr:6,cudamempoolattrusedmemhigh:6,cudamempoolcr:6,cudamempooldestroi:6,cudamempoolexportpoint:6,cudamempoolexporttoshareablehandl:6,cudamempoolgetaccess:6,cudamempoolgetattribut:6,cudamempoolimportfromshareablehandl:6,cudamempoolimportpoint:6,cudamempoolprop:6,cudamempoolptrexportdata:6,cudamempoolreuseallowinternaldepend:6,cudamempoolreuseallowopportunist:6,cudamempoolreusefolloweventdepend:6,cudamempoolsetaccess:6,cudamempoolsetattribut:6,cudamempooltrimto:6,cudamemprefetchasync:[5,6],cudamemrangeattribut:6,cudamemrangeattributeaccessedbi:6,cudamemrangeattributelastprefetchloc:6,cudamemrangeattributepreferredloc:6,cudamemrangeattributereadmostli:6,cudamemrangegetattribut:[5,6],cudamemset2d:[5,6],cudamemset2dasync:[5,6],cudamemset3d:6,cudamemset3dasync:6,cudamemset:[5,6],cudamemsetasync:[5,6],cudamemsetparam:6,cudamipmappedarray_const_t:6,cudamipmappedarray_t:6,cudamipmappedarraygetlevel:6,cudamipmappedarraygetmemoryrequir:6,cudamipmappedarraygetsparseproperti:6,cudanvscisyncattrsign:6,cudanvscisyncattrwait:6,cudaoccupancyavailabledynamicsmemperblock:6,cudaoccupancydefault:6,cudaoccupancydisablecachingoverrid:6,cudaoccupancymaxactiveblockspermultiprocessor:[5,6],cudaoccupancymaxactiveblockspermultiprocessorwithflag:[5,6],cudaoccupancymaxactiveclust:5,cudaoccupancymaxpotentialblocks:[5,6],cudaoccupancymaxpotentialblocksizevariablesmem:6,cudaoccupancymaxpotentialblocksizevariablesmemwithflag:6,cudaoccupancymaxpotentialblocksizewithflag:[5,6],cudaoutputmode_t:6,cudapeekatlasterror:6,cudapeeraccessdefault:6,cudapitchedptr:6,cudapo:6,cudapointerattribut:6,cudapointergetattribut:[5,6],cudaprofil:16,cudaprofileriniti:[6,12],cudaprofilerstart:[5,6,12],cudaprofilerstop:[5,6,12],cudareadmodeelementtyp:6,cudareadmodenormalizedfloat:6,cudaresourcedesc:6,cudaresourcetyp:6,cudaresourcetypearrai:6,cudaresourcetypelinear:6,cudaresourcetypemipmappedarrai:6,cudaresourcetypepitch2d:6,cudaresourceviewdesc:6,cudaresourceviewformat:6,cudaresviewformatfloat1:6,cudaresviewformatfloat2:6,cudaresviewformatfloat4:6,cudaresviewformathalf1:6,cudaresviewformathalf2:6,cudaresviewformathalf4:6,cudaresviewformatnon:6,cudaresviewformatsignedblockcompressed4:6,cudaresviewformatsignedblockcompressed5:6,cudaresviewformatsignedblockcompressed6h:6,cudaresviewformatsignedchar1:6,cudaresviewformatsignedchar2:6,cudaresviewformatsignedchar4:6,cudaresviewformatsignedint1:6,cudaresviewformatsignedint2:6,cudaresviewformatsignedint4:6,cudaresviewformatsignedshort1:6,cudaresviewformatsignedshort2:6,cudaresviewformatsignedshort4:6,cudaresviewformatunsignedblockcompressed1:6,cudaresviewformatunsignedblockcompressed2:6,cudaresviewformatunsignedblockcompressed3:6,cudaresviewformatunsignedblockcompressed4:6,cudaresviewformatunsignedblockcompressed5:6,cudaresviewformatunsignedblockcompressed6h:6,cudaresviewformatunsignedblockcompressed7:6,cudaresviewformatunsignedchar1:6,cudaresviewformatunsignedchar2:6,cudaresviewformatunsignedchar4:6,cudaresviewformatunsignedint1:6,cudaresviewformatunsignedint2:6,cudaresviewformatunsignedint4:6,cudaresviewformatunsignedshort1:6,cudaresviewformatunsignedshort2:6,cudaresviewformatunsignedshort4:6,cudart:[0,3,13],cudaruntimegetvers:[5,6],cudasetdevic:[5,6],cudasetdeviceflag:[5,6],cudasetdoublefordevic:6,cudasetdoubleforhost:6,cudasetvaliddevic:[6,11,12,13,14,15,16,17,18],cudasharedcarveout:6,cudasharedmembanksizedefault:6,cudasharedmembanksizeeightbyt:6,cudasharedmembanksizefourbyt:6,cudasharedmemcarveoutdefault:6,cudasharedmemcarveoutmaxl1:6,cudasharedmemcarveoutmaxshar:6,cudasharedmemconfig:6,cudasignalexternalsemaphoresasync:6,cudastream_t:[5,6,13],cudastreamaddcallback:[5,6],cudastreamaddcapturedepend:6,cudastreamattachmemasync:[5,6],cudastreamattrid:6,cudastreamattrvalu:6,cudastreambegincaptur:6,cudastreamcallback_t:6,cudastreamcapturemod:6,cudastreamcapturemodeglob:6,cudastreamcapturemoderelax:6,cudastreamcapturemodethreadloc:6,cudastreamcapturestatu:6,cudastreamcapturestatusact:6,cudastreamcapturestatusinvalid:6,cudastreamcapturestatusnon:6,cudastreamcopyattribut:6,cudastreamcr:[5,6],cudastreamcreatewithflag:[5,6],cudastreamcreatewithprior:[5,6],cudastreamdefault:6,cudastreamdestroi:[5,6],cudastreamendcaptur:6,cudastreamgetattribut:6,cudastreamgetcaptureinfo:6,cudastreamgetcaptureinfo_v2:6,cudastreamgetflag:[5,6],cudastreamgetprior:[5,6],cudastreamiscaptur:6,cudastreamlegaci:[5,6],cudastreamnonblock:[6,13],cudastreamperthread:[5,6],cudastreamqueri:[5,6,13],cudastreamsetattribut:6,cudastreamsetcapturedepend:6,cudastreamsynchron:[5,6],cudastreamupdatecapturedepend:6,cudastreamupdatecapturedependenciesflag:6,cudastreamwaitev:[5,6],cudasuccess:[6,13],cudasurfaceboundarymod:6,cudasurfaceformatmod:6,cudasurfaceobject_t:6,cudasurfacetype1d:6,cudasurfacetype1dlay:6,cudasurfacetype2d:6,cudasurfacetype2dlay:6,cudasurfacetype3d:6,cudasurfacetypecubemap:6,cudasurfacetypecubemaplay:6,cudasynchronizationpolici:6,cudasyncpolicyauto:6,cudasyncpolicyblockingsync:6,cudasyncpolicyspin:6,cudasyncpolicyyield:6,cudatextureaddressmod:6,cudatexturedesc:6,cudatexturedesc_v2:6,cudatexturefiltermod:6,cudatextureobject_t:6,cudatexturereadmod:6,cudatexturetype1d:6,cudatexturetype1dlay:6,cudatexturetype2d:6,cudatexturetype2dlay:6,cudatexturetype3d:6,cudatexturetypecubemap:6,cudatexturetypecubemaplay:6,cudathreadexchangestreamcapturemod:6,cudathreadgetcacheconfig:6,cudathreadsetcacheconfig:6,cudatriggerprogrammaticlaunchcomplet:5,cudatypedef:[5,6],cudaunbindtextur:[11,12],cudauserobject_t:6,cudauserobjectcr:6,cudauserobjectflag:6,cudauserobjectnodestructorsync:6,cudauserobjectreleas:6,cudauserobjectretain:6,cudauserobjectretainflag:6,cudauuid_t:6,cudavdpaugetdevic:[5,6,12],cudavdpausetvdpaudevic:[6,12,13,14,15,16,17,18],cudavers:5,cudawaitexternalsemaphoresasync:6,cudawglgetdevic:12,cudestroyexternalmemori:5,cudestroyexternalsemaphor:5,cudevic:[5,9],cudevice_attribut:5,cudevice_p2pattribut:5,cudevice_v1:5,cudevicecanaccessp:[5,6],cudeviceget:[5,9],cudevicegetattribut:[5,6],cudevicegetbypcibusid:[5,6],cudevicegetcount:[5,6],cudevicegetdefaultmempool:[5,6],cudevicegetexecaffinitysupport:5,cudevicegetgraphmemattribut:5,cudevicegetluid:5,cudevicegetmaxtexture1dlinear:6,cudevicegetmempool:[5,6],cudevicegetnam:[5,6],cudevicegetnvscisyncattribut:5,cudevicegetp2pattribut:[5,6],cudevicegetpcibusid:[5,6],cudevicegettexture1dlinearmaxwidth:[5,6],cudevicegetuuid:5,cudevicegetuuid_v2:5,cudevicegraphmemtrim:5,cudeviceprimaryctxgetst:[5,6],cudeviceprimaryctxreleas:5,cudeviceprimaryctxreset:5,cudeviceprimaryctxretain:5,cudeviceprimaryctxsetflag:[5,6],cudeviceptr:[5,9],cudeviceptr_v2:5,cudevicesetdefaultmempool:6,cudevicesetgraphmemattribut:5,cudevicesetmempool:[5,6],cudevicetotalmem:5,cudevprop:5,cudevprop_st:5,cudevprop_v1:5,cudrivergetvers:[5,6],cudriverprocaddress_flag:5,cueglcolorformat:5,cueglfram:5,cueglframe_st:5,cueglframe_v1:5,cueglframetyp:5,cueglresourcelocationflag:5,cueglstreamconnect:5,cueglstreamconsumeracquirefram:[5,6,12],cueglstreamconsumerconnect:[5,6,12],cueglstreamconsumerconnectwithflag:[5,6,12],cueglstreamconsumerdisconnect:[5,6,12],cueglstreamconsumerreleasefram:[5,6,12],cueglstreamproducerconnect:[5,6,12],cueglstreamproducerdisconnect:[5,6,12],cueglstreamproducerpresentfram:[5,6,12],cueglstreamproducerreturnfram:[5,6,12],cuevent:[5,6],cuevent_capture_flag:5,cuevent_flag:5,cuevent_record_flag:5,cuevent_sched_flag:5,cuevent_wait_flag:5,cueventcr:[5,6],cueventcreatefromeglsync:[5,12],cueventdestroi:[5,6],cueventelapsedtim:[5,6],cueventqueri:[5,6],cueventrecord:[5,6],cueventrecordwithflag:5,cueventsynchron:[5,6],cuexecaffinityparam:5,cuexecaffinityparam_st:5,cuexecaffinityparam_v1:5,cuexecaffinitysmcount:5,cuexecaffinitysmcount_st:5,cuexecaffinitysmcount_v1:5,cuexecaffinitytyp:5,cuexternalmemori:5,cuexternalmemorygetmappedbuff:5,cuexternalmemorygetmappedmipmappedarrai:5,cuexternalmemoryhandletyp:5,cuexternalsemaphor:5,cuexternalsemaphorehandletyp:5,cufilter_mod:5,cuflushgpudirectrdmawrit:[5,6],cuflushgpudirectrdmawritesopt:5,cuflushgpudirectrdmawritesscop:5,cuflushgpudirectrdmawritestarget:5,cuformat:5,cufreeasync:[5,6],cufunc_cach:5,cufuncgetattribut:[5,6],cufuncgetmodul:5,cufuncsetattribut:5,cufuncsetblockshap:5,cufuncsetcacheconfig:[5,6],cufuncsetsharedmemconfig:[5,6],cufuncsetshareds:5,cufunct:[5,6],cufunction_attribut:5,cufunctionsetattribut:5,cugeterrornam:[5,6],cugeterrorstr:[5,6],cugetprocaddress:[5,6],cuglctxcreat:12,cugldevicelist:5,cuglgetdevic:[5,6,12],cuglinit:12,cuglmapbufferobject:12,cuglmapbufferobjectasync:12,cuglregisterbufferobject:12,cuglsetbufferobjectmapflag:12,cuglunmapbufferobject:12,cuglunmapbufferobjectasync:12,cuglunregisterbufferobject:12,cugpudirectrdmawritesord:5,cugraph:[5,6],cugraphaddbatchmemopnod:5,cugraphaddchildgraphnod:5,cugraphadddepend:5,cugraphaddemptynod:5,cugraphaddeventrecordnod:5,cugraphaddeventwaitnod:5,cugraphaddexternalsemaphoressignalnod:5,cugraphaddexternalsemaphoreswaitnod:5,cugraphaddhostnod:5,cugraphaddkernelnod:5,cugraphaddmemallocnod:5,cugraphaddmemcpynod:5,cugraphaddmemfreenod:5,cugraphaddmemsetnod:5,cugraphbatchmemopnodegetparam:5,cugraphbatchmemopnodesetparam:5,cugraphchildgraphnodegetgraph:5,cugraphclon:5,cugraphcr:5,cugraphdebugdot_flag:5,cugraphdebugdotprint:5,cugraphdestroi:5,cugraphdestroynod:5,cugrapheventrecordnodegetev:5,cugrapheventrecordnodesetev:5,cugrapheventwaitnodegetev:5,cugrapheventwaitnodesetev:5,cugraphexec:[5,6],cugraphexecbatchmemopnodesetparam:5,cugraphexecchildgraphnodesetparam:5,cugraphexecdestroi:5,cugraphexeceventrecordnodesetev:5,cugraphexeceventwaitnodesetev:5,cugraphexecexternalsemaphoressignalnodesetparam:5,cugraphexecexternalsemaphoreswaitnodesetparam:5,cugraphexechostnodesetparam:5,cugraphexeckernelnodesetparam:5,cugraphexecmemcpynodesetparam:5,cugraphexecmemsetnodesetparam:5,cugraphexecupd:5,cugraphexecupdateresult:5,cugraphexternalsemaphoressignalnodegetparam:5,cugraphexternalsemaphoressignalnodesetparam:5,cugraphexternalsemaphoreswaitnodegetparam:5,cugraphexternalsemaphoreswaitnodesetparam:5,cugraphgetedg:5,cugraphgetnod:5,cugraphgetrootnod:5,cugraphhostnodegetparam:5,cugraphhostnodesetparam:5,cugraphicsd3d10registerresourc:5,cugraphicsd3d11registerresourc:5,cugraphicsd3d9registerresourc:5,cugraphicseglregisterimag:[5,6,12],cugraphicsglregisterbuff:[5,6,12],cugraphicsglregisterimag:[5,6,12],cugraphicsmapresourc:[5,6],cugraphicsmapresourceflag:5,cugraphicsregisterflag:5,cugraphicsresourc:[5,6],cugraphicsresourcegetmappedeglfram:[5,6,12],cugraphicsresourcegetmappedmipmappedarrai:[5,6],cugraphicsresourcegetmappedpoint:5,cugraphicsresourcesetmapflag:[5,6],cugraphicssubresourcegetmappedarrai:[5,6],cugraphicsunmapresourc:[5,6],cugraphicsunregisterresourc:[5,6],cugraphicsvdpauregisteroutputsurfac:[5,6,12],cugraphicsvdpauregistervideosurfac:[5,6,12],cugraphinstanti:5,cugraphinstantiate_flag:[5,6],cugraphinstantiatewithflag:5,cugraphkernelnodecopyattribut:5,cugraphkernelnodegetattribut:5,cugraphkernelnodegetparam:5,cugraphkernelnodesetattribut:5,cugraphkernelnodesetparam:5,cugraphlaunch:5,cugraphmem_attribut:5,cugraphmemallocnodegetparam:5,cugraphmemcpynodegetparam:5,cugraphmemcpynodesetparam:5,cugraphmemfreenodegetparam:5,cugraphmemsetnodegetparam:5,cugraphmemsetnodesetparam:5,cugraphnod:[5,6],cugraphnodefindinclon:5,cugraphnodegetdepend:5,cugraphnodegetdependentnod:5,cugraphnodegeten:5,cugraphnodegettyp:5,cugraphnodeseten:5,cugraphnodetyp:5,cugraphreleaseuserobject:5,cugraphremovedepend:5,cugraphretainuserobject:5,cugraphupload:5,cuhostfn:5,cuimportexternalmemori:5,cuimportexternalsemaphor:5,cuinit:[5,9],cuipcclosememhandl:[5,6],cuipceventhandl:5,cuipceventhandle_st:5,cuipceventhandle_v1:5,cuipcgeteventhandl:[5,6],cuipcgetmemhandl:[5,6],cuipcmem_flag:5,cuipcmemhandl:5,cuipcmemhandle_st:5,cuipcmemhandle_v1:5,cuipcopeneventhandl:[5,6],cuipcopenmemhandl:[5,6],cujit_cachemod:5,cujit_cachemode_enum:5,cujit_fallback:5,cujit_opt:5,cujit_target:5,cujitinputtyp:5,cukernelnodeattrid:5,cukernelnodeattrvalu:5,cukernelnodeattrvalue_v1:5,culaunchattribut:5,culaunchattribute_st:5,culaunchattributeid:5,culaunchattributevalu:5,culaunchattributevalue_union:5,culaunchconfig:5,culaunchconfig_st:5,culaunchcooperativekernel:5,culaunchcooperativekernelmultidevic:5,culaunchhostfunc:[5,6],culaunchkernel:[5,9],culaunchkernelex:5,culimit:5,culink:5,culinkadddata:5,culinkaddfil:5,culinkcomplet:5,culinkcr:5,culinkdestroi:5,culinkst:5,cumem_advis:5,cumem_range_attribut:5,cumemaccess_flag:5,cumemaccessdesc:5,cumemaccessdesc_st:5,cumemaccessdesc_v1:5,cumemaddressfre:5,cumemaddressreserv:5,cumemadvis:[5,6],cumemalloc:[5,6,9],cumemalloc_v2:[5,6],cumemallocasync:[5,6],cumemallocationcomptyp:5,cumemallocationgranularity_flag:5,cumemallocationhandletyp:[5,6],cumemallocationprop:5,cumemallocationprop_st:5,cumemallocationprop_v1:5,cumemallocationtyp:5,cumemallocfrompoolasync:[5,6],cumemallochost:[5,6],cumemallocmanag:[5,6],cumemallocpitch:[5,6],cumemattach_flag:5,cumemcpi:[5,6],cumemcpy2d:[5,6],cumemcpy2dasync:[5,6],cumemcpy2dunalign:[5,6],cumemcpy3d:[5,6],cumemcpy3dasync:[5,6],cumemcpy3dp:[5,6],cumemcpy3dpeerasync:[5,6],cumemcpyasync:[5,6],cumemcpyatoa:5,cumemcpyatod:5,cumemcpyatoh:5,cumemcpyatohasync:5,cumemcpydtoa:5,cumemcpydtod:[5,6],cumemcpydtodasync:[5,6],cumemcpydtoh:[5,6],cumemcpydtohasync:[5,6,9],cumemcpyhtoa:5,cumemcpyhtoaasync:5,cumemcpyhtod:[5,6],cumemcpyhtodasync:[5,6,9],cumemcpyp:[5,6],cumemcpypeerasync:[5,6],cumemcr:[5,6],cumemexporttoshareablehandl:5,cumemfre:[5,6,9],cumemfreeasync:[5,6],cumemfreehost:[5,6],cumemgenericallocationhandl:5,cumemgenericallocationhandle_v1:5,cumemgetaccess:5,cumemgetaddressrang:5,cumemgetallocationgranular:5,cumemgetallocationpropertiesfromhandl:5,cumemgethandleforaddressrang:5,cumemgetinfo:[5,6],cumemhandletyp:5,cumemhostalloc:[5,6],cumemhostgetdevicepoint:[5,6],cumemhostgetflag:[5,6],cumemhostregist:[5,6],cumemhostunregist:[5,6],cumemimportfromshareablehandl:5,cumemloc:5,cumemlocation_st:5,cumemlocation_v1:5,cumemlocationtyp:[5,6],cumemmap:5,cumemmaparrayasync:[5,6],cumemoperationtyp:5,cumemorypool:[5,6],cumemorytyp:5,cumemorytype_enum:5,cumempool:5,cumempool_attribut:5,cumempoolcr:[5,6],cumempooldestroi:[5,6],cumempoolexportpoint:[5,6],cumempoolexporttoshareablehandl:[5,6],cumempoolgetaccess:[5,6],cumempoolgetattribut:[5,6],cumempoolimportfromshareablehandl:[5,6],cumempoolimportpoint:[5,6],cumempoolprop:5,cumempoolprops_st:5,cumempoolprops_v1:5,cumempoolptrexportdata:5,cumempoolptrexportdata_st:5,cumempoolptrexportdata_v1:5,cumempoolsetaccess:[5,6],cumempoolsetattribut:[5,6],cumempooltrimto:[5,6],cumemprefetchasync:[5,6],cumemprot:[5,6],cumemrangegetattribut:[5,6],cumemrangehandletyp:5,cumemreleas:5,cumemretainallocationhandl:5,cumemsetaccess:5,cumemsetd16:[5,6],cumemsetd16async:[5,6],cumemsetd2d16:[5,6],cumemsetd2d16async:[5,6],cumemsetd2d32:[5,6],cumemsetd2d32async:[5,6],cumemsetd2d8:[5,6],cumemsetd2d8async:[5,6],cumemsetd32:[5,6],cumemsetd32async:[5,6],cumemsetd8:[5,6],cumemsetd8async:[5,6],cumemunmap:5,cumipmappedarrai:5,cumipmappedarraycr:[5,6],cumipmappedarraydestroi:[5,6],cumipmappedarraygetlevel:[5,6],cumipmappedarraygetmemoryrequir:5,cumipmappedarraygetsparseproperti:5,cumodul:5,cumodulegetfunct:[5,9],cumodulegetglob:5,cumodulegetloadingmod:5,cumodulegetsurfref:5,cumodulegettexref:5,cumoduleload:5,cumoduleloaddata:[5,9],cumoduleloaddataex:5,cumoduleloadfatbinari:5,cumoduleloadingmod:5,cumoduleunload:[5,9],cuoccupancy_flag:5,cuoccupancyavailabledynamicsmemperblock:5,cuoccupancyb2ds:5,cuoccupancymaxactiveblockspermultiprocessor:[5,6],cuoccupancymaxactiveblockspermultiprocessorwithflag:[5,6],cuoccupancymaxactiveclust:5,cuoccupancymaxpotentialblocks:5,cuoccupancymaxpotentialblocksizewithflag:5,cuoccupancymaxpotentialclusters:5,cuparamsetf:5,cuparamseti:5,cuparamsets:5,cuparamsetv:5,cupi:8,cupointer_attribut:5,cupointergetattribut:[5,6],cupointersetattribut:5,cuprofileriniti:[5,12],cuprofilerstart:[5,6,12],cuprofilerstop:[5,6,12],curesourcetyp:[5,6],curesourceviewformat:5,curesult:[5,9],current:[4,5,6,7,9],cushared_carveout:5,cusharedconfig:5,cusignalexternalsemaphoresasync:5,custream:[5,6],custream_flag:5,custreamaddcallback:[5,6],custreamattachmemasync:[5,6],custreamattrid:5,custreamattrvalu:5,custreamattrvalue_v1:5,custreambatchmemop:5,custreambatchmemop_v2:5,custreambatchmemopparam:5,custreambatchmemopparams_union:5,custreambatchmemopparams_v1:5,custreambatchmemoptyp:5,custreambegincaptur:[5,6],custreamcallback:5,custreamcapturemod:5,custreamcapturestatu:5,custreamcopyattribut:5,custreamcr:[5,6,9],custreamcreatewithprior:[5,6],custreamdestroi:[5,6,9],custreamendcaptur:5,custreamgetattribut:5,custreamgetcaptureinfo:5,custreamgetcaptureinfo_v2:5,custreamgetctx:5,custreamgetflag:[5,6],custreamgetprior:[5,6],custreamiscaptur:5,custreamlaunchhostfunc:5,custreammemopflushremotewritesparams_st:5,custreammemopmemorybarrierparams_st:5,custreammemopwaitvalueparams_st:[5,13],custreammemopwritevalueparams_st:5,custreammemorybarri:5,custreammemorybarrier_flag:5,custreamqueri:[5,6],custreamsetattribut:5,custreamsynchron:[5,6,9],custreamupdatecapturedepend:5,custreamupdatecapturedependencies_flag:5,custreamwaitev:[5,6],custreamwaitvalue32:5,custreamwaitvalue32_v2:5,custreamwaitvalue64:5,custreamwaitvalue64_v2:5,custreamwaitvalue_flag:5,custreamwritevalue32:5,custreamwritevalue32_v2:5,custreamwritevalue64:5,custreamwritevalue64_v2:5,custreamwritevalue_flag:5,cusurfobject:[5,6],cusurfobject_v1:5,cusurfobjectcr:[5,6],cusurfobjectdestroi:[5,6],cusurfobjectgetresourcedesc:[5,6],cusurfref:5,cusurfrefsetarrai:5,cusynchronizationpolici:5,cutexobject:[5,6],cutexobject_v1:5,cutexobjectcr:[5,6],cutexobjectdestroi:[5,6],cutexobjectgetresourcedesc:[5,6],cutexobjectgetresourceviewdesc:[5,6],cutexobjectgettexturedesc:[5,6],cutexref:5,cutexrefsetaddress2d:5,cutexrefsetarrai:5,cutexrefsetflag:5,cuthreadexchangestreamcapturemod:5,cuuint64_t:[5,6,13],cuuserobject:5,cuuserobject_flag:5,cuuserobjectcr:5,cuuserobjectreleas:5,cuuserobjectretain:5,cuuserobjectretain_flag:5,cuuuid:[5,6],cuuuid_st:[5,6],cuvdpauctxcr:[5,12],cuvdpaugetdevic:[5,6,12],cuwaitexternalsemaphoresasync:5,cuwglgetdevic:12,cyclic:5,cython:[8,11,12],d3d11:[5,6],d3d12:[5,6],d3dkmt_handl:[5,6],d:[6,7],daemon:[5,6],dash:7,data:[0,8,9],datas:[5,6],datatyp:[5,6],dc:7,deadlock:5,debug:[4,5,6,7],decid:[5,6],declar:[5,6,16],decomposit:14,decreas:[5,6],decrement:[5,6],dedic:[5,6],deefault:6,deem:1,deep:[8,9],def:[7,9],default_program:7,defer:[5,6],defin:[1,5,6,7,16,17],definit:[5,6,7],degrad:[5,6],deiniti:6,delet:[5,6],deliv:9,denorm:[5,7],denot:[5,6,7],depend:[4,5,6,16],dependencies_out:[5,6],dependentnod:5,deprec:[5,6,13],depth:[5,6],depth_textur:5,dereferenc:[5,6],deriv:[5,6],derogatori:1,desc:[5,6],desclist:6,describ:[2,5,6,7],descript:[5,6],descriptor:[5,6],design:[5,9],desir:[5,6],destin:[5,6],destroi:[5,6,7],destructor:[5,6],detail:[1,5,6,9],detect:[5,6,9],determin:[1,5,6,7],determinist:[5,6],dev:[5,6],develop:[5,6,8,9],deviat:[5,6],devic:[0,7,9],devicebitmask:5,devicelist:[5,6],devicenodemask:5,deviceoverlap:6,devicepoint:6,devptr:[5,6],dfma:7,dgpu:[5,6],diag:7,diagnost:[5,6,7],dialect:7,did:[5,6],differ:[1,5,6,8,9],dim3:6,dim:[5,9],dimens:[5,6],dimension:[5,6],dir:7,direct3d:0,direct:[5,6,7],directli:[5,6,7],directmanagedmemaccessfromhost:6,directori:[4,7,17],directx:[5,6],disabl:[1,5,6,7,17],disabletrilinearoptim:6,disallow:[5,6],disconnect:[5,6],discourag:6,discret:[5,6],discuss:[5,6],disjoint:[5,6],displai:[5,6,7],disregard:6,distinct:[5,6],div:[5,7],divis:[5,7],dlcm:[5,6],dlink:7,dlto:[5,7],dma:5,dma_buf:5,doc:[3,5,6],docs_src:4,document:[2,4,5,6],doe:[5,6,9],doesn:[5,6,9],domain:[5,6],don:[5,6],done:[5,6,13],dopt:7,dot:[5,6],doubl:[5,6],dout:9,doutclass:9,down:[5,6],downstream:5,dpitch:6,dptr:[5,6],dptr_out:[5,6],dq:7,drive:5,driver:[0,4,8,9],driver_typ:16,driververs:[5,6],dst:[5,6],dstarrai:[5,6],dstcontext:5,dstdevic:[5,6],dstheight:5,dsthost:5,dstlod:5,dstmemorytyp:5,dstoffset:5,dstpitch:5,dstpo:6,dstptr:6,dstxinbyt:5,dsty:5,dstz:5,dtype:9,due:[5,6],duplic:[5,6],durat:[5,6],dure:[5,6,7,16],dw:7,dx:9,dxclass:9,dy:9,dyclass:9,dynam:[5,6,9],dynamicsmems:[5,6],e:[1,4,5,6,7,17],ea:11,each:[5,6,7,9],earlier:[5,6,9],easi:[8,9],easier:9,ecc:[5,6],eccen:6,econom:1,ecosystem:[8,9],edg:[5,6],edit:[1,4],educ:1,effect:[5,6],effici:[5,6],eg:[5,6],egl:[0,12,13],egl_fals:5,egl_support_reuse_nv:5,egl_tru:5,eglcolorformat:[5,6],eglfram:[5,6],eglimag:[5,6],eglimagekhr:[5,6],eglint:[5,6],eglsream:[5,6],eglstream:[5,6],eglstreamkhr:[5,6],eglsync:[5,6],eglsynckhr:[5,6],eight:[5,6],either:[5,6,7],elaps:[5,6],electron:1,element:[5,6],elements:[5,6],elementsizebyt:5,elif:9,elimin:9,els:[5,9],emb:7,embed:[5,6,7],emit:7,empathi:1,emploi:[5,6],empti:[5,6],emul:6,enabl:[5,6,7,9,17],encod:[5,6,9],encount:[2,5,6],encourag:[5,6],end:[5,6,7],endpoint:[5,6],enforc:[3,6],engin:[5,6,8,9],enough:[5,6],enqueu:[5,6],ensur:[5,6,9],entir:[5,6,7,9],entiti:7,entri:[0,8],enumer:[5,6,7],env:[4,5],environ:[1,4,5,6,13],equal:[5,6,7],equival:[5,6,7],err:[7,9],error:[0,9,16],errornod:5,especi:[5,6],establish:[5,6],estim:[5,6],etc:[5,6],ethnic:1,evalu:2,even:[5,6,7,9],evenli:5,event:[0,1,9],event_out:[5,6],eventu:[5,6],everi:[5,6],everyon:1,evict:[5,6],ewp:7,ex:[5,6],exact:[5,6],exactli:[5,6],examin:[5,6],exampl:[1,5,6,9,13],exce:[5,6],exceed:[5,6],except:[5,6,9],excess:[5,6],exchang:[5,6],exclud:[5,6],exclus:[5,6],execut:[0,7,8,9,13],exhaust:[5,6],exhibit:5,exist:[5,6,8],exit:6,expand:[5,6],expans:5,expect:[1,5,6,9],experi:[1,9],explan:13,explicit:[1,5,6],explicitli:[5,6,7],exportdata:6,expos:5,express:[1,5,6,7],extend:[5,6],extens:[4,5,6,7],extent:[5,6],extentdepth:5,extentheight:5,extentwidth:5,extern:[0,9],extmem:[5,6],extmem_out:[5,6],extra:[5,6,7,9],extract:[7,9],extsem:[5,6],extsem_out:[5,6],extsemarrai:[5,6],f:[4,5,6],face:[1,5,6,16],facil:5,facilit:[5,6],fact:6,fail:[5,6,9],failur:[5,6],fair:1,faith:1,fall:[2,5,6],fallback:[5,6],fals:[5,7,9],famili:[5,6],faq:1,fashion:[5,6],fast:[5,7],faster:[5,6,7,8],fastest:[5,6],fat:5,fatal:[5,6],fatbin:5,fatcubin:5,fault:[5,6],fd:[5,6],featur:[2,5,6,7],fenc:[5,6],fetch:[5,6],fewer:[5,6,8],fewest:5,ffma:7,field:[5,6],fifo:[5,6],fig:9,file:[2,5,6],filenam:5,fill:[5,6],filter:[5,6],filtermod:[5,6],find:[5,6],findresourc:5,finish:[5,6,9],finit:[5,6],first:[5,6,7,9],firstlay:[5,6],firstmipmaplevel:[5,6],fit:[5,6],fix:[2,5,6,14,16],flag:[5,6],flage:6,flight:5,float16:5,float32:9,floor:[5,6],flush:[5,6,7],flushremotewrit:5,fma:5,fmad:[7,9],fmtdesc:6,fn:[5,6],fname:5,fo:5,focus:1,follow:[1,4,5,6,7,9,16],foo:5,foobaz:5,footprint:8,forbid:[5,6],forbidden:[5,6],forc:[5,6],fork:[5,6],form:[5,6,7,9],format:[5,6,9],formatdesc:6,former:5,forward:[5,6,7],foster:1,found:[5,6,16],foundat:[8,9],four:[5,6],frame:[5,6],frametyp:[5,6],free:[1,5,6],freed:[5,6],frequenc:[5,6],frequent:[5,6],from:[1,3,5,6,7,8,9,13,16],from_:[5,6],ftz:[5,7],full:[5,8,9],fulli:5,func:[5,6],func_nam:6,funcptr:6,fundament:9,further:[1,5,6],futur:[3,5,6,8,11,12,16],g:[4,5,6,7],ga:12,gather:[5,6],gbrg:[5,6],gdb:4,gemini:6,gender:1,gener:[0,5,6,9],get:[5,6,7,8,9],getptr:[5,6,7],getsharedhandl:[5,6],gh:4,git:4,gitlab:16,give:[5,6],given:[5,6,7],gl:[12,13],gl_alpha:[5,6],gl_intens:[5,6],gl_lumin:[5,6],gl_luminance_alpha:[5,6],gl_r16:[5,6],gl_r8:[5,6],gl_r:[5,6],gl_red:[5,6],gl_renderbuff:[5,6],gl_rg16:[5,6],gl_rg8:[5,6],gl_rg:[5,6],gl_rgba:[5,6],gl_texture_2d:[5,6],gl_texture_2d_arrai:[5,6],gl_texture_3d:[5,6],gl_texture_cube_map:[5,6],gl_texture_rectangl:[5,6],glcontext:[5,6],glenum:[5,6],glfinish:[5,6],global:[5,6,7],globall1cachesupport:6,gluint:[5,6],go:[5,6,9],goal:[8,9],good:[1,5,6,7],gpu:[5,6,7,8,9],gpudirect:[5,6],gr:[5,6],grab:9,gracefulli:1,grant:[5,6],granular:[5,6],graph:0,graph_out:[5,6],graphexec:[5,6],graphic:[0,13],grbg:[5,6],greater:[5,6,7],greatest:[5,6],greatestprior:[5,6],grid:[5,6,9],grid_group:6,griddepcontrol:[5,6],griddim:6,griddimi:5,griddimx:5,griddimz:5,group:[5,6],guarante:[5,6],guid:[4,5,6],guidanc:4,h:[5,6,16],ha:[5,6,8,9,16,17],had:[5,6],half:[5,6],halt:9,hand:[5,6,8],handl:[0,9,13],handle_out:[5,6],handletyp:[5,6],handwritten:5,happen:[5,6],harass:1,hardwar:[5,6],harm:1,harrai:[5,6],have:[1,5,6,7,8,9,16,17],haven:[5,6],hclonedgraph:5,hdst:6,header:[5,6,7,16,17],heap:[5,6],height:[5,6],held:[5,6],help:[5,6,8,9],helper:7,henc:[5,7],hend:5,here:[5,6,9],herrornode_out:[5,6],heurist:[5,6],hevent:5,hexadecim:[5,6],hfunc:5,hgraph:[5,6],hgraphexec:[5,6],high:[5,6],higher:[5,6,7,9],highest:[5,6],highli:6,hightlight:10,hint:[5,6],hit:[5,6],hitprop:[5,6],hitratio:[5,6],hmipmappedarrai:5,hmod:5,hnode:[5,6],hoffset:6,hoffsetdst:6,hoffsetsrc:6,hold:[5,6],honor:5,horiginalgraph:5,horiginalnod:5,host:[5,6,8,9],hostnativeatomicsupport:6,hostpoint:6,hostptr:6,hout:9,how:[5,6,9],howev:[5,6,7],hpc:8,hsrc:6,hstart:5,hstream:[5,6],html:[1,4,5],http:[1,5,6,16],hx:9,hy:9,hz:9,i:[5,6,7,17],id3d11fenc:[5,6],id3d11resourc:[5,6],id3d12devic:[5,6],id3d12fenc:[5,6],id3d12heap:[5,6],id3d12resourc:[5,6],id:[5,6],id_out:[5,6],ident:[1,5,6,7,9],identif:5,identifi:[5,6],idl:[5,6],idxgikeyedmutex:[5,6],idxgiresourc:[5,6],idxgiresource1:[5,6],ieee:[5,7],ignor:[5,6,9],igpu:[5,6],illeg:[5,6],imag:[5,6],imageri:1,immedi:[5,6,9],impact:[5,6],imper:5,impl_priv:6,implement:[2,5,6],impli:[5,6,7],implic:6,implicit:[5,6,7],implicitli:[5,6],implict:5,importantli:9,impos:[5,6],improp:5,improv:[5,6,9],inact:5,inappropri:1,inbetween:6,incid:1,includ:[1,5,6,7,16,17],includenam:7,inclus:[1,8],incompat:[5,6,9],incomplet:[5,6],inconsist:[5,6],incorpor:5,incorrect:6,increas:[5,6,7,9],increasingli:8,increment:[5,6],incur:[5,6],indefinit:[5,6],independ:[5,6],index:[3,4,5,6],indic:[5,6,7],indirectli:5,individu:[1,5,6,7,9],infer:[5,6],infinit:[5,6],info:[5,6,7],inform:[0,1,5,6,9],infrequ:[5,6],inhibit:7,initi:[0,6,7,9,11],initializer_list:7,initialrefcount:[5,6],inlin:7,inplac:4,input:[5,6,7,9],insert:[5,6],insid:[5,6],insight:9,inspect:[5,6],instal:[3,5,6,18],instanc:[1,5,6,7],instanti:[5,6],instead:[5,6,7,16],instruct:[5,6,9,18],insuffici:[5,6],insult:1,int128:7,int32_t:5,int64_t:5,int_max:[5,6],integ:[5,6],integr:[5,6],intend:[5,6],inter:[5,6],interact:[0,5,9],interchang:6,interest:[1,2],interfac:[5,6,8,9],interleav:[5,6],intermedi:[5,7],intern:[5,6],interop:[5,6],interoper:[0,9,10],interpret:[5,6,9],interprocess:[5,6],interv:[5,6],intra:[5,6],introduc:[5,6,9],introduct:9,intuit:9,invalid:[5,6],investig:1,invoc:5,invok:[5,6],involv:[5,6],ipc:[5,6],isa:9,isen:[5,6],isinst:9,ismultigpuboard:6,isn:[5,6],isp:[5,6],isssu:6,issu:[1,2,5,6,16,17,18],item:[5,6],items:9,iter:8,its:[1,5,6,8,9],janurai:13,jargon:8,jit:[5,6],join:[5,6],jump:9,june:16,just:[5,6],keep:[5,6],kei:[5,6,9],kernel:[5,6,7],kernelexectimeouten:6,kernelparam:[5,6],keyedmutex:[5,6],keyword:[5,6],kilohertz:[5,6],kind:[5,6,7],kmt:[5,6],know:[5,6],known:[5,6],kwarg:[5,6,7],l1:[5,6],l2:[5,6],l2caches:6,languag:[1,7,8,9],laps:[5,6],larg:[5,6],larger:[5,6],largest:5,last:[5,6,9],lastlay:[5,6],lastmipmaplevel:[5,6],latenc:[5,6],later:[4,5,6,7,9],latest:[4,5,6,16,17,18],latter:5,launch:[5,6,9,13,14,15,16,17,18],launch_depend:[5,6],launchdep:5,launchparamslist:5,layer:[5,6],layout:[5,6],lazi:5,lazili:5,lead:5,leadership:1,learn:[5,8,9],least:[5,6],leastprior:[5,6],leav:[5,6],left:6,legaci:[5,6,13],legal:[5,6],length:[5,6],less:[5,6,7],let:[5,6],level:[1,5,6,9,11,12],levelarrai:6,leverag:[5,6,9],li:[5,6],librari:[4,5,6,8,9,14],licens:[5,6],lie:6,life:5,lifetim:[5,6],lighter:8,lightweight:[5,6],like:[5,6,9],likewis:[5,6],limit:[5,6,7,10],line:[5,6,7,9],linear:[5,6],lineinfo:[5,7],link:[5,6,7],link_sync_behavior:[5,6],linker:5,linux:[4,5,6,7],list:[5,6,7,9],load:[5,6,9,14],local:[4,5,6],locall1cachesupport:6,localsizebyt:6,locat:[5,6,9,17],lock:[5,6],lod:5,lode:5,log2:[5,6],log:[5,6,7,9],logbuff:5,logic:[5,6],logsizeret:7,longer:[5,6,16,17],look:[5,6],loop:6,low:[5,6,9,11,12],lower:[5,6,7,8],lowered_nam:7,lowest:[5,6],lpsecurityattribut:[5,6],lsb:[5,6],luid:[5,6],luiddevicenodemask:6,lumin:[5,6],mac:[5,6],machin:[5,9],macro:[5,6,7],made:[5,6],mai:[1,5,6,7,9,15,16],mail:1,maintain:[1,5,6],mainten:8,major:[4,5,6,7],make:[1,4,5,6,7],make_cudaext:6,make_cudapitchedptr:6,make_cudapo:6,malloc:[5,6],manag:0,managedmemori:6,mandat:[5,6],mangl:[5,7],mani:[5,6],manner:5,manual:[5,6,9],map:[5,6],mapinfolist:5,mappabl:5,march:14,mark:[5,6],mask:[5,6],massiv:9,match:[4,5,6,9],math:7,matrix:[5,6],matthew:9,max:[5,6],max_plan:5,maxanisotropi:[5,6],maxblockspermultiprocessor:6,maxdynamicsharedsizebyt:6,maxgrids:[5,6],maxim:[5,6,9],maximum:[5,6,7],maxmipmaplevelclamp:[5,6],maxrregcount:7,maxsurface1d:6,maxsurface1dlay:6,maxsurface2d:6,maxsurface2dlay:6,maxsurface3d:6,maxsurfacecubemap:6,maxsurfacecubemaplay:6,maxtexture1d:6,maxtexture1dlay:6,maxtexture1dlinear:6,maxtexture1dmipmap:6,maxtexture2d:6,maxtexture2dgath:6,maxtexture2dlay:6,maxtexture2dlinear:6,maxtexture2dmipmap:6,maxtexture3d:6,maxtexture3dalt:6,maxtexturecubemap:6,maxtexturecubemaplay:6,maxthreadsdim:[5,6],maxthreadsperblock:[5,6],maxthreadspermultiprocessor:6,maxwel:[5,6],maxwidthinel:[5,6],mean:[5,6],meaning:[5,6],meant:[5,6],measur:[5,6],mechan:[5,6],media:1,meet:[5,6],mem:5,memaddressreserv:5,membar:5,member:[1,5,6,7,13],memcpi:[5,6],memhandl:5,memhandledesc:[5,6],memhandletyp:5,memop:[5,6],memoperationtyp:5,memori:[0,7,8,9],memorybarri:5,memorybuswidth:6,memoryclockr:6,memoryrequir:[5,6],mempitch:[5,6],mempool:[5,6],memset:[5,6],memsetparam:5,merg:[5,6],messag:[5,6,7],met:[5,6],method:5,microsecond:[5,6],mig:5,might:[5,6],migrat:[5,6],millisecond:[5,6],minbytestokeep:[5,6],mind:[5,6],mingrids:5,minim:[5,6],minimum:[5,6,7,8],minmipmaplevelclamp:[5,6],minor:[4,5,6,7,17],mip:[5,6],miplevel:[5,6],mipmap:[5,6],mipmapdesc:[5,6],mipmapfiltermod:[5,6],mipmaplevelbia:[5,6],mipmappedarrai:6,miptail:5,miptailfirstlevel:[5,6],miptails:[5,6],mirror:[5,6],misc:7,misconfigur:[5,6],mismatch:[5,6],miss:[5,6,17],missprop:[5,6],mix:[5,6],mobil:[16,17],mode:[5,6,7],model:[5,6,9],modif:[5,6],modifi:[5,6,7],modprob:5,modul:[0,3,4,6,8,9],more:[5,6,7,8,9],most:[5,6,8,9],mostli:[5,6],motherboard:6,motiv:3,move:[5,6,7],movement:9,movntdqa:5,mp:[5,6],ms:[5,6],much:[5,6],multi:[5,6],multi_grid_group:6,multidimension:[5,6],multigpuboardgroupid:6,multipl:[5,6,9],multiplanar:[5,6],multipli:[5,7],multiprocessor:[5,6],multiprocessorcount:6,multisampl:[5,6],must:[4,5,6,7,9],mutex:[5,6],n:[5,6,7,9],name:[5,6,7],name_express:7,narrow:6,nation:1,nativ:[5,6],natur:[5,9],nearest:[5,6,7],nearli:9,necessari:[1,5,6],necessarili:[5,6],need:[2,5,6,9,16,17],neg:[5,6],neither:6,nest:[5,6],network:8,never:[5,6],newer:[5,6],newli:[5,6],next:[5,6,9],nice:9,node:[5,6],nodeparam:[5,6],nodeparams_out:5,non:[5,6,7],none:[5,6,9],nonzero:[5,6],nor:6,normal:[5,6],normalizedcoord:6,note:[3,4,5,6,7,9],noth:[5,6],notifi:2,novemb:18,now:[5,6,8,9,13,16,17],np:9,nsight:9,nsy:9,nt:[5,6],nullabl:5,num_block:9,num_byt:[5,6],num_thread:9,numarch:7,numattr:5,numattribut:[5,6],numba:8,number:[5,6,7],numblock:[5,6],numbyt:5,numchannel:[5,6],numclust:5,numdepend:[5,6],numdependencies_out:[5,6],numdependentnod:5,numdevic:5,numedg:[5,6],numer:[5,6],numextsem:[5,6],numhead:7,numlevel:[5,6],nummipmaplevel:5,numnod:[5,6],numopt:[5,7],numparam:5,numpi:[8,9],numreg:6,numrootnod:5,nv:5,nvcc:[5,6],nvcl:5,nvcl_ctx_sched_auto:5,nvcl_ctx_sched_blocking_sync:5,nvcl_ctx_sched_spin:5,nvcl_ctx_sched_yield:5,nvcl_event_sched_auto:5,nvcl_event_sched_blocking_sync:5,nvcl_event_sched_spin:5,nvcl_event_sched_yield:5,nvidia:[1,2,4,5,6,8,9,16],nvidia_p2p_get_pag:[5,6],nvlink:[5,6],nvreg_enablestreammemop:5,nvrtc:[0,3,4,9,16],nvrtc_error:7,nvrtc_error_builtin_operation_failur:7,nvrtc_error_compil:7,nvrtc_error_internal_error:7,nvrtc_error_invalid_input:7,nvrtc_error_invalid_opt:7,nvrtc_error_invalid_program:7,nvrtc_error_name_expression_not_valid:7,nvrtc_error_no_lowered_names_before_compil:7,nvrtc_error_no_name_expressions_after_compil:7,nvrtc_error_out_of_memori:7,nvrtc_error_program_creation_failur:7,nvrtc_success:[7,9],nvrtcaddnameexpress:7,nvrtccompileprogram:[7,9],nvrtccreateprogram:[7,9],nvrtcdestroyprogram:7,nvrtcgetcubin:7,nvrtcgetcubins:7,nvrtcgeterrorstr:7,nvrtcgetlowerednam:7,nvrtcgetnumsupportedarch:7,nvrtcgetnvvm:7,nvrtcgetnvvmsiz:7,nvrtcgetprogramlog:[7,9],nvrtcgetprogramlogs:7,nvrtcgetptx:[7,9],nvrtcgetptxsiz:[7,9],nvrtcgetsupportedarch:7,nvrtcprogram:7,nvrtcresult:[7,9],nvrtcversion:7,nvscibuf:[5,6],nvscibufobject:[5,6],nvscisync:[5,6],nvscisyncattr:[5,6],nvscisyncattrkey_requiredperm:[5,6],nvscisyncattrlist:[5,6],nvscisyncobj:[5,6],nvvm:[5,7],nvvmsizeret:7,o:[5,6],obei:[5,6],obj:[5,6],object:[0,9],object_out:[5,6],oblig:1,observ:[5,6],obtain:[4,5,6],occasion:[5,6],occassion:[5,6],occup:0,occupi:6,occur:[5,6],octet:5,octob:[12,17],off:[5,6,7],offens:1,offici:1,offlin:1,offset:[5,6],offseti:5,offsetx:5,offsetz:5,often:[5,6],old:5,older:[5,6],omit:[5,6,9],onc:[5,6],one:[5,6,7,8],ones:5,ongo:[5,6],onli:[4,5,6,7,9,11],onlin:[1,5],onto:[5,6],op:[5,6],opaqu:[5,6,7],open:[1,4,5,6],opengl:0,oper:[0,6,7,9],operand:[5,6],opportunist:[5,6],oppos:6,opt:[5,6,7,9],optim:[5,6,7],optin:[5,6],option:[0,5,6,13,14,15,16,17,18],optionvalu:5,order:[0,7],ordin:[5,6],org:1,orient:[1,9],origin:[5,6],originalgraph:[5,6],originalnod:6,orthogon:[5,6],os:[5,6],oshandl:5,ote_null_stream:5,ote_sync:6,other:[1,4,5,6,7],otherwis:[1,5,6,7],our:[3,8,9],out:[5,6,9],outlin:[4,5,6],output:[5,6,7,9],outsid:[5,6,9],outstand:[5,6],over:[5,6],overal:9,overflow:[5,6],overhead:[5,6,8],overlap:[5,6,9],overload:6,overrid:[5,6],overridden:5,oversubscript:[5,6],overview:[3,5,6],overwrit:[5,6],overwritten:[5,6],own:[5,6,8,9],ownership:[5,6],p2p:[5,6],p2ptoken:5,p:[5,6],pack:5,packag:[4,5,6,9,11],pad:[5,6],page:[3,4,5,6],pageabl:[5,6],pageablememoryaccess:6,pageablememoryaccessuseshostpaget:6,pair:[5,6],pairless:[5,6],pallocatearrai:5,parallel:[5,6,7,8,9],param:[5,6],paramarrai:5,paramet:[5,6,7,9],params_out:[5,6],paramsarrai:[5,6],parrai:5,parraydescriptor:5,pars:17,part:[5,6,9],parti:[5,6],particip:[1,5,6],particular:[5,6,7,16],partit:[5,6],pass:[4,5,6,7,9],path:[5,6,7,8],pattern:[5,6],pbase:5,pcacheconfig:6,pcapturestatu:6,pci:[5,6],pcibusid:[5,6],pcideviceid:6,pcidomainid:6,pcie:[5,6],pclonednod:6,pconfig:[5,6],pcopi:5,pcopyparam:6,pctx:5,pcudadevic:[5,6],pcudadevicecount:[5,6],pcudaresourc:[5,6],pdepend:6,pdependentnod:6,pdevic:[5,6],pdevptr:5,pdptr:5,peak:[5,6],peer:0,peercontext:5,peerdev:5,peerdevic:6,pend:[5,6],per:[5,6,9,13],percent:[5,6],percentag:[5,6],perform:[3,5,6,7],perman:1,permiss:[1,5,6],permit:[5,6],perrornod:6,persist:[5,6],persistingl2cachemaxs:6,persit:[5,6],person:1,perspect:6,pervious:5,pexecaffin:5,pflag:[5,6],pfn:5,pformat:5,pfrom:6,pgraph:6,pgraphclon:6,pgraphexec:6,pgraphnod:6,phandl:5,phase:[5,6,7],phclonednod:5,pherrornod:5,phevent:[5,6],phgraph:5,phgraphclon:5,phgraphexec:5,phgraphnod:[5,6],phnode:5,phost:6,phstream:5,physic:[1,5,6],pi:5,pick:[5,6],pid:6,piec:[5,6],pin:[5,6],pip:4,pipelin:[5,6],pipi:4,pitch2d:[5,6],pitch:[5,6],pitcheddevptr:6,pitchinbyt:[5,6],place:[5,6,9],placehold:5,plai:9,planar:[5,6],plane:[5,6],planecount:[5,6],planedesc:6,planeidx:[5,6],platform:[4,5,6,11,12,16,17],pleas:[5,6],pledg:3,plevelarrai:5,plogbuff:6,pmemsetparam:6,pmillisecond:5,pmipmappedarrai:5,pmipmappedarraydesc:5,pnode:6,pnodeparam:6,pnumdepend:6,pnumdependentnod:6,pnumrootnod:6,pobject_attribut:5,point:[0,7,9],pointer:[5,6,7,9],polici:[1,5,6],polit:1,pool:[5,6,7],pool_out:[5,6],poolprop:[5,6],pop:[5,6],popul:[5,6,7],popular:8,port:4,portabl:[5,6,9],portion:[5,6],posit:[1,5,6],posix:[5,6],possibl:[5,6,9],post:1,potenti:[5,6],power:[5,6],pp:5,ppitch:5,pplanearrai:[5,6],ppointer:5,practic:9,pre:[5,6,7],prec:[5,7],preced:[5,6,7],precis:[5,6,7],predefin:7,predict:5,preempt:[5,6],preemption:[5,6],prefer:[5,6,8],preferredshmemcarveout:6,prefetch:[5,6],preinclud:7,prep:9,prepar:9,preprocess:7,preprocessor:7,presdesc:[5,6],present:[5,6,7],preserv:[5,6,7],presviewdesc:[5,6],prevent:[5,6],previou:[5,6,7,17],previous:[5,6,7],primari:[0,6,9],primarili:[5,6],primit:[5,6,10],print:5,printf:[5,6],prior:[5,6],prioriti:[2,5,6],privat:1,problem:8,proce:[6,9],procedur:[5,6],process:[5,6,7,8,9],processor:[5,6],produc:[5,6],product:6,profession:1,profil:[0,9,13],prog:[7,9],program:[5,6,7,8,9],programm:[5,6,7],programmat:[5,6],programmaticev:[5,6],programmaticstreamserializationallow:[5,6],progress:[5,6],prohibit:[5,6],project:1,promis:[5,6],promot:[5,6],prone:[5,6],prootnod:6,prop:[5,6],propag:16,proper:6,properli:[5,6],properti:[5,6],proprietari:[5,6],protect:[5,6],proucer:[5,6],provid:[5,6,7,8,9],psize:5,psrc:5,pstr:5,pstream:[5,6],psurfobject:[5,6],psurfref:5,ptd:13,ptexdesc:[5,6],ptexobject:[5,6],ptexref:5,pto:6,ptr:[5,6],ptr_out:[5,6],ptx:[5,6,7,9],ptxa:7,ptxsize:9,ptxsizeret:7,ptxversion:6,ptype:6,publish:1,pure:[5,6],purpos:[5,6],push:[5,6],pvalu:[5,6],px:5,py:[4,5,6],pypi:[3,12],python:[1,2,4],queri:[0,5,6],question:1,quickli:[5,6],quot:9,r:[5,6],race:[1,5,6],rais:[6,9],rand:9,random:9,rang:[5,6],rapid:8,rather:[5,6],ratio:[5,6],rccb:[5,6],rdc:7,rdma:[5,6],re:[5,6,9,16],reach:[5,6],read:[5,6],readi:[5,6,9],readmod:6,real:[5,6],realloc:[5,6],reason:[1,5,6],receiv:[5,6],recent:[5,6,9],recepi:5,recipi:[5,6],reciproc:[5,7],recogn:[5,6],recommend:[5,6],reconstruct:5,record:[5,6],recov:[5,6],recurs:[5,6],redistribut:4,reduc:[5,6,7],reenabl:[5,6],refcount:[5,6],refer:[3,5,6],referenc:[5,6],reflect:[5,6],regard:[1,5,6],regardless:[1,5,6],region:[5,6],regist:[5,6,7],registr:[5,6],regsperblock:[5,6],regspermultiprocessor:6,reiniti:6,reject:1,rel:[5,6],relat:[5,6],relationship:6,relaunch:[5,6],relax:[13,16],releas:[2,3,5,6,7,8,9],reli:[5,6],religion:1,reloc:5,relocat:7,remain:[4,5,6],remark:7,rememb:9,remot:[5,6],remov:[1,5,6,13,17],render:[5,6],renderbuff:[5,6],reorder:5,repercuss:1,replac:[5,6,8],replai:[5,6],report:[1,2,5,6,7],repres:[1,5,6],represent:[1,5,6],request:[2,5,6],requestedhandletyp:5,requir:[3,5,6,7,9,17],reserv:[5,6],reserved0:5,reserved1:5,reservedsharedmemperblock:6,reset:[5,6,7],resid:[5,6,9],resiz:[5,6],resolut:[5,6],resolv:[5,6,16,17,18],resour:5,resourc:[0,9],resourcetyp:5,respect:[1,5,6],respons:[3,5,6],responsibl:5,rest:[5,6],restor:[5,6],restrict:[5,6,7],restyp:[5,6],result:[1,5,6,7,9],retain:[5,6],retri:[5,6,9],retriev:[5,6,9],returnd:6,reus:[5,6],revert:[5,6],review:1,revis:6,rgb:5,rgba:[5,6],rggb:[5,6],right:1,role:9,room:[5,6],root:[4,5,6,7],rootnod:5,round:[5,6,7],routin:0,row:[5,6],rule:[5,6],run:[4,5,6,9],runtim:[0,5,7,8,9,16],runtimeerror:9,runtimevers:6,s:[1,5,6,7,8,9,17],safe:[5,6],sake:[5,6],same:[5,6,7,9],sampl:[5,6],satisfi:[5,6],saxpi:9,scenario:[5,6],sched:5,schedul:[2,5,6],scienc:[8,9],scipi:8,scope:[3,5,6],screenshot:9,se:[5,6],seamless:[5,6],seamlesscubemap:6,search:[3,5,6,7],second:[5,6],secondarili:6,section:[5,6],secur:[5,6],see:[1,2,5,6,7,9,13],seen:6,segment:[5,6],select:[5,6,7],self:6,semant:[5,6],semaphor:[5,6],semhandledesc:[5,6],sent:[5,6],separ:[1,5,6,7],sequenc:[5,6],serial:[5,6,9],serv:[5,6],server:[5,6],set:[1,4,5,6,7,8,9,13],setrlimit:7,setup:[4,5,6],sever:[5,6],sex:1,sexual:1,shall:[5,6],shape:[5,6],share:[5,6,9],shareabl:[5,6],shareablehandl:[5,6],sharedata:[5,6],sharedata_out:[5,6],sharedmem:6,sharedmembyt:[5,6],sharedmemperblock:[5,6],sharedmemperblockoptin:6,sharedmempermultiprocessor:6,sharedsizebyt:6,shhandletyp:5,shorter:6,should:[5,6,7,9],show:[1,9],shown:5,shut:[5,6],side:[5,6],sign:[5,6],signal:[5,6],signatur:[5,13],signific:[5,6],significantli:[5,6],silent:6,simdwidth:5,similar:[5,6],similarli:5,simpli:[5,6],simplif:9,simplifi:8,simultan:[5,6],sinc:[5,6],singl:[5,6,7,8,9],singletodoubleprecisionperfratio:6,singli:[5,6],situat:[5,6],six:[5,6],size:[1,5,6,7,9],size_t:[5,6,9],sizeinbyt:[5,6],sizeof:[5,6],sizeout:5,skip:[5,6],sku:5,slate:[5,6],sli:[5,6],slice:[5,6],slot:[5,6],slow:5,slower:5,sm:[5,6],sm_35:7,sm_37:7,sm_50:7,sm_52:7,sm_53:7,sm_60:7,sm_61:7,sm_62:7,sm_70:7,sm_72:7,sm_75:7,sm_80:7,sm_87:7,sm_89:7,sm_90:[5,7],small:5,smaller:[5,6,8],smi:5,so:[5,6,9],soc:[5,6],social:1,socio:1,solv:8,some:[5,6,9],someth:[5,6],sometim:6,sophist:8,sort:7,sourc:[3,5,6,7,10,11],space:[1,5,6,7],span:5,sparingli:[5,6],spars:[5,6],sparselevel:5,sparseproperti:[5,6],special:[5,6],specif:[1,4,5,6,7,9],specifi:[5,6,7],speed:[5,8],spent:5,spin:[5,6],spitch:6,split:[5,6],spread:[5,6],sqrt:[5,7],squar:[5,7],src:[5,6,7],srcarrai:[5,6],srccontext:5,srcdevic:[5,6],srcheight:5,srchost:5,srclod:5,srcmemorytyp:5,srcoffset:5,srcpitch:5,srcpo:6,srcptr:6,srcxinbyt:5,srcy:5,srcz:5,srgb:[5,6],sse4:5,stack:[5,6,7],stage:[5,6],standalon:5,standard:[3,8,9],start:[5,6],startup:6,stat:9,state:[5,6],stateout:5,statu:[1,5,6],status:[5,6],std:7,step:[4,9],still:[4,5,6,17],storag:[5,6],store:[5,6,7,9],str:9,strategi:5,strcutur:5,stream:[0,9,10,12],streamprioritiessupport:6,string:[5,6,7,9,14],strongli:6,struct:[5,6],structcudachannelformatdescchanneldesc:6,structur:[5,6,13],stub:[5,6],style:6,sub:[5,6],subject:9,submit:[5,6],subregion:[5,6],subresourc:[5,6],subresourcetyp:5,subroutin:5,subscrib:5,subsequ:[5,6,7],subset:[5,6],substanti:6,subsystem:[5,6],subtract:[5,7],succe:[6,7],succeed:[5,6],success:[5,6],successfulli:[5,6],suggest:5,suit:[5,6],suitabl:[5,6],sum:[5,6],suport:5,supplant:[5,6],suppli:[5,6],support:[0,4,5,6,8,10],supportedarch:7,suppport:5,suppress:[5,6,7],surfac:0,surfacealign:6,surfacerefer:6,surfobject:[5,6],sustain:[5,6],swap:[5,6],symbol:[5,6,13,14,15,16,17,18],symmetr:[5,6],sync:[5,6],synchron:[5,6,13],syncpolici:[5,6],synonym:6,syntax:8,sysmem:[5,6],system:[5,6,9],t:[5,6,9],tabl:[5,6,9],tag:7,tail:[5,6],take:[1,5,6,7,9],taken:6,target:[5,6,7,8,9],task:[5,6],tcc:[5,6],tccdriver:6,team:[1,2],tear:6,tegra:[5,6],templat:6,template_arg_0:6,template_arg_n:6,tempor:[5,6],temporari:[1,16],temporarili:[1,5,6],tenet:[5,6],term:[6,16],termin:[5,6],tesla:[5,6],test:[4,5,6],texobject:[5,6],texref:5,text:5,textur:0,texture1d_mipmapped_width:5,texture1d_width:5,texturealign:[5,6],texturepitchalign:6,texturerefer:6,texunit:5,than:[5,6,7],thank:2,thei:[1,5,6,7],them:[2,5,6,7,9],themselv:5,therebi:7,therefor:[5,6,9,17],thi:[1,2,5,6,7,9,10],thing:9,third:[5,6],those:[5,6],though:[5,6],thrash:[5,6],thread:[5,6,7,9,13],threadidx:9,threaten:1,three:[5,6,7,9],threshold:[5,6],through:[5,6,13],thu:[5,6],tid:9,tile:[5,6],tileext:[5,6],time:[2,5,6,7],timelin:[5,6],timeout:[5,6],timeoutm:[5,6],timingdata:[5,6],titl:5,todai:9,togeth:8,token:[5,7],toler:9,too:[5,6],took:[5,6],tool:[5,6,9],toolchain:[5,6],toolkit:[4,5,6,8,13,15,17],top:[5,6,8,9],topolog:[5,6],total:[5,6],totalconstantmemori:5,totalconstmem:6,totalglobalmem:6,toward:[1,9],traceback:9,track:[5,6,13],trade:7,trail:7,tranfer:[5,6],transact:5,transfer:[5,6,9],transform:9,transit:[5,6],translat:[7,9],transmit:5,trap:6,travel:6,treat:[5,6,7],tri:[5,6],triag:2,trigger:[5,6],triggeratblockstart:[5,6],trilinear:[5,6],trim:[5,6],trimto:[5,6],tripl:9,troll:1,truncat:[5,6,7],tune:[5,6],ture:9,turn:[5,6,7],twice:[5,6],two:[2,5,6,7],txt:4,type:[0,2,7,9,16,17],typedef:[5,6],typedefstructcudaeglplanedesc_st:6,typenam:5,typic:[5,6],u:[5,6,7],uc:5,ui:5,uint32:9,uint64:9,unabl:[5,6],unaccept:1,unaffect:[5,6],unari:5,unavail:[5,6],unbound:[5,6],uncommon:9,uncorrect:[5,6],undefin:[5,6,7],under:[5,6],underli:[5,6],underlin:13,understand:9,undo:[5,6],unexpect:[5,6],unfre:[5,6],unhandl:6,unidirect:[5,6],unifi:[0,8,9],unifiedaddress:6,uniform:8,union:[5,6],uniqu:[5,6],unison:8,unit:[5,6,7,9],unknown:[5,6,7,9],unless:[5,6],unlik:[5,6],unload:[5,6],unmap:[5,6],unnecessari:5,unprivileg:5,unreach:[5,6],unrecogn:[6,7],unreferenc:5,unregist:[5,6],unreleas:5,unresolv:5,unsaf:[5,6],unset:[5,6],unsign:[5,6],unsignedintdepth:6,unsignedintheight:6,unsignedintnumchannel:6,unsignedintpitch:6,unsignedintreserv:6,unsignedintwidth:6,unspecifi:[5,6],unsupport:[5,6],until:[5,6,7,9],unus:[5,6],unwelcom:1,up:[5,6,7,9],updat:[5,6,7,18],updateresult_out:[5,6],upfront:[5,6],upgrad:[5,6],upload:[5,6],upon:[5,6],upper:[5,6],us:[0,1,4,7,8,9,16,17,18],usabl:[5,6],usag:[5,6],use_fast_math:7,usec:[5,6],user:[5,6,8],userdata:[5,6],usr:4,usual:[5,6],utf:[5,6],util:[5,8],uuid:[5,6],uv:[5,6],uva:5,uyvi:[5,6],v10u10:[5,6],v12u12:[5,6],v1:5,v2:5,v3:5,v:[5,6],va:5,val:[5,6],valid:[5,6,7],valu:[5,6,7,9,13],value64:13,value_out:[5,6],valueerror:9,vanish:6,vari:[5,6],variabl:[4,5,6,7,13],variant:5,variat:17,variou:5,vaspacetoken:5,vdpau:[0,12,13],vdpdevic:[5,6],vdpgetprocaddress:[5,6],vdpoutputsurfac:[5,6],vdpsurfac:[5,6],vdpvideosurfac:[5,6],vector:[7,9],verbos:5,veri:6,verif:9,verifi:[5,6],versa:[5,6],version:[0,1,4,7,9],versu:5,via:[1,4,5,6,7],vice:[5,6],video:[5,6],vidmem:[5,6],view:[5,6],viewpoint:1,violat:[5,6],virtual:[0,6,7,9],visibl:[5,6],vista:[5,6],visual:[5,6],vkflushmappedmemoryrang:[5,6],vkinvalidatemappedmemoryrang:[5,6],void_ptr:[5,6],volatil:[5,6],volta:[5,6],vu:[5,6],vui:5,vulkan:[5,6],vuya:[5,6],vyui:[5,6],w:[5,6,7],wa:[5,6,7,9],wai:[5,6,9],wait:[5,6],waiter:[5,6],waitparam:13,waitvalu:5,wall:5,want:[2,5,6,8,9],warn:[5,7],warp:[5,6],warpsiz:6,watermark:[5,6],wc:[5,6],we:[1,2,8,9],welcom:1,well:[5,6],were:[5,6],what:[1,2,3,5,6],wheel:8,when:[1,5,6,7,8,9,13],whenev:[5,6],where:[5,6],whether:[5,6],which:[1,5,6,7,9],who:1,whole:[5,6,7],whose:[5,6],why:[3,5,6],wide:[5,6],width:[5,6],widthinbyt:5,wiki:1,wildcard:5,win32:[5,6],win32handlemetadata:5,win32securityattribut:[5,6],window:[4,5,6],within:[1,5,6,9],without:[1,5,6,7],woffset:6,woffsetdst:6,woffsetsrc:6,won:[5,6],word:[5,6],work:[5,6,9],workaround:[16,17],workflow:3,world:8,would:[5,6,9],wrap:[5,6,9,13],wraparound:5,wrapper:[8,11,12],write:[5,6,9],writevalu:5,written:[5,6],wrong:5,wsl:14,www:1,x:[5,6,9,11,12],xptxa:[5,6,7],xsize:6,xsz:6,xx:9,y10:[5,6],y12:[5,6],y:[5,6,9],yet:[5,6,9],yield:[5,6],yml:4,you:[2,4,5,6,8,9],your:[2,4,6,9],ysize:6,ysz:6,yuv420planar:[5,6],yuv422planar:[5,6],yuv444planar:[5,6],yuv:[5,6],yuyv:[5,6],yvyu:[5,6],z:[5,6,9],zero:[5,6,7,9]},titles:["CUDA Python API Reference","Code of Conduct","Contributing","CUDA Python Manual","Installation","cuda","cudart","nvrtc","Motivation","Overview","Release Notes","CUDA Python 11.4.0 Release notes","CUDA Python 11.5.0 Release notes","CUDA Python 11.6.0 Release notes","CUDA Python 11.6.1 Release notes","CUDA Python 11.7.0 Release notes","CUDA Python 11.7.1 Release notes","CUDA Python 11.8.0 Release notes","CUDA Python 11.8.1 Release notes"],titleterms:{"0":[11,12,13,15,17],"1":[14,16,18],"10":6,"11":[6,11,12,13,14,15,16,17,18],"4":11,"5":12,"6":[13,14],"7":[15,16],"8":[17,18],"9":6,"default":13,"function":[11,12,13,14,15,16,17,18],In:4,Not:[11,12,13,14,15,16,17,18],access:[5,6],address:[5,6],alloc:[5,6],api:[0,6],applic:9,attribut:1,build:[4,16,17],c:6,captionhold:0,code:1,comparison:9,compil:7,conda:4,conduct:1,content:3,context:5,contribut:2,control:[5,6],cuda:[0,3,5,6,8,9,11,12,13,14,15,16,17,18],cudart:6,data:[5,6],develop:4,devic:[5,6],direct3d:6,doc:4,driver:[5,6],egl:[5,6],enforc:1,entri:[5,6],error:[5,6,7],event:[5,6],execut:[5,6],extern:[5,6],from:4,futur:9,gener:7,graph:[5,6],graphic:[5,6],handl:[5,6,7],hightlight:[11,12,13,14,15,16,17,18],indic:3,inform:7,initi:5,instal:4,interact:6,interoper:[5,6,13],kernel:9,limit:[11,12,13,14,15,16,17,18],manag:[5,6],manual:3,memori:[5,6],modul:5,motiv:8,note:[10,11,12,13,14,15,16,17,18],nvrtc:7,object:[5,6],occup:[5,6],opengl:[5,6],oper:5,option:7,order:[5,6],our:1,overview:[1,9],peer:[5,6],perform:9,place:4,pledg:1,point:[5,6],primari:5,primit:13,profil:[5,6],publish:4,pypi:4,python:[0,3,8,9,11,12,13,14,15,16,17,18],queri:7,refer:0,releas:[10,11,12,13,14,15,16,17,18],requir:4,resourc:[5,6],respons:1,routin:6,runtim:6,scope:1,sourc:[4,16,17],standard:1,stream:[5,6,13],support:[7,11,12,13,14,15,16,17,18],surfac:[5,6],tabl:3,textur:[5,6],thi:[11,12,13,14,15,16,17,18],type:[5,6],unifi:[5,6],us:[5,6],vdpau:[5,6],version:[5,6],virtual:5,what:8,why:8,workflow:9}})
\ No newline at end of file
+Search.setIndex({docnames:["api","conduct","contribute","index","install","module/cuda","module/cudart","module/nvrtc","motivation","overview","release","release/11.4.0-notes","release/11.5.0-notes","release/11.6.0-notes","release/11.6.1-notes","release/11.7.0-notes","release/11.7.1-notes","release/11.8.0-notes","release/11.8.1-notes"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":5,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":3,"sphinx.domains.rst":2,"sphinx.domains.std":2,sphinx:56},filenames:["api.rst","conduct.md","contribute.md","index.rst","install.md","module/cuda.rst","module/cudart.rst","module/nvrtc.rst","motivation.md","overview.md","release.md","release/11.4.0-notes.md","release/11.5.0-notes.md","release/11.6.0-notes.md","release/11.6.1-notes.md","release/11.7.0-notes.md","release/11.7.1-notes.md","release/11.8.0-notes.md","release/11.8.1-notes.md"],objects:{"cuda.cuda":[[5,0,1,"","CUDA_ARRAY3D_2DARRAY"],[5,0,1,"","CUDA_ARRAY3D_COLOR_ATTACHMENT"],[5,0,1,"","CUDA_ARRAY3D_CUBEMAP"],[5,0,1,"","CUDA_ARRAY3D_DEFERRED_MAPPING"],[5,0,1,"","CUDA_ARRAY3D_DEPTH_TEXTURE"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR_st"],[5,1,1,"","CUDA_ARRAY3D_DESCRIPTOR_v2"],[5,0,1,"","CUDA_ARRAY3D_LAYERED"],[5,0,1,"","CUDA_ARRAY3D_SPARSE"],[5,0,1,"","CUDA_ARRAY3D_SURFACE_LDST"],[5,0,1,"","CUDA_ARRAY3D_TEXTURE_GATHER"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR_st"],[5,1,1,"","CUDA_ARRAY_DESCRIPTOR_v2"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS_st"],[5,1,1,"","CUDA_ARRAY_MEMORY_REQUIREMENTS_v1"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES_st"],[5,1,1,"","CUDA_ARRAY_SPARSE_PROPERTIES_v1"],[5,1,1,"","CUDA_BATCH_MEM_OP_NODE_PARAMS"],[5,1,1,"","CUDA_BATCH_MEM_OP_NODE_PARAMS_st"],[5,0,1,"","CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC"],[5,0,1,"","CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC"],[5,0,1,"","CUDA_EGL_INFINITE_TIMEOUT"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1"],[5,0,1,"","CUDA_EXTERNAL_MEMORY_DEDICATED"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1"],[5,0,1,"","CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st"],[5,1,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1"],[5,0,1,"","CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st"],[5,1,1,"","CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS_st"],[5,1,1,"","CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1"],[5,1,1,"","CUDA_HOST_NODE_PARAMS"],[5,1,1,"","CUDA_HOST_NODE_PARAMS_st"],[5,1,1,"","CUDA_HOST_NODE_PARAMS_v1"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS_st"],[5,1,1,"","CUDA_KERNEL_NODE_PARAMS_v1"],[5,1,1,"","CUDA_LAUNCH_PARAMS"],[5,1,1,"","CUDA_LAUNCH_PARAMS_st"],[5,1,1,"","CUDA_LAUNCH_PARAMS_v1"],[5,1,1,"","CUDA_MEMCPY2D"],[5,1,1,"","CUDA_MEMCPY2D_st"],[5,1,1,"","CUDA_MEMCPY2D_v2"],[5,1,1,"","CUDA_MEMCPY3D"],[5,1,1,"","CUDA_MEMCPY3D_PEER"],[5,1,1,"","CUDA_MEMCPY3D_PEER_st"],[5,1,1,"","CUDA_MEMCPY3D_PEER_v1"],[5,1,1,"","CUDA_MEMCPY3D_st"],[5,1,1,"","CUDA_MEMCPY3D_v2"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS_st"],[5,1,1,"","CUDA_MEMSET_NODE_PARAMS_v1"],[5,1,1,"","CUDA_MEM_ALLOC_NODE_PARAMS"],[5,1,1,"","CUDA_MEM_ALLOC_NODE_PARAMS_st"],[5,0,1,"","CUDA_NVSCISYNC_ATTR_SIGNAL"],[5,0,1,"","CUDA_NVSCISYNC_ATTR_WAIT"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st"],[5,1,1,"","CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1"],[5,1,1,"","CUDA_RESOURCE_DESC"],[5,1,1,"","CUDA_RESOURCE_DESC_st"],[5,1,1,"","CUDA_RESOURCE_DESC_v1"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC_st"],[5,1,1,"","CUDA_RESOURCE_VIEW_DESC_v1"],[5,1,1,"","CUDA_TEXTURE_DESC"],[5,1,1,"","CUDA_TEXTURE_DESC_st"],[5,1,1,"","CUDA_TEXTURE_DESC_v1"],[5,0,1,"","CUDA_VERSION"],[5,1,1,"","CUGLDeviceList"],[5,1,1,"","CUGPUDirectRDMAWritesOrdering"],[5,0,1,"","CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL"],[5,0,1,"","CU_DEVICE_CPU"],[5,0,1,"","CU_DEVICE_INVALID"],[5,0,1,"","CU_IPC_HANDLE_SIZE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE"],[5,0,1,"","CU_KERNEL_NODE_ATTRIBUTE_PRIORITY"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_POINTER"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_SIZE"],[5,0,1,"","CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT"],[5,0,1,"","CU_LAUNCH_PARAM_END"],[5,0,1,"","CU_LAUNCH_PARAM_END_AS_INT"],[5,0,1,"","CU_MEMHOSTALLOC_DEVICEMAP"],[5,0,1,"","CU_MEMHOSTALLOC_PORTABLE"],[5,0,1,"","CU_MEMHOSTALLOC_WRITECOMBINED"],[5,0,1,"","CU_MEMHOSTREGISTER_DEVICEMAP"],[5,0,1,"","CU_MEMHOSTREGISTER_IOMEMORY"],[5,0,1,"","CU_MEMHOSTREGISTER_PORTABLE"],[5,0,1,"","CU_MEMHOSTREGISTER_READ_ONLY"],[5,0,1,"","CU_MEM_CREATE_USAGE_TILE_POOL"],[5,0,1,"","CU_PARAM_TR_DEFAULT"],[5,0,1,"","CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY"],[5,0,1,"","CU_STREAM_LEGACY"],[5,0,1,"","CU_STREAM_PER_THREAD"],[5,0,1,"","CU_TRSA_OVERRIDE_FORMAT"],[5,0,1,"","CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION"],[5,0,1,"","CU_TRSF_NORMALIZED_COORDINATES"],[5,0,1,"","CU_TRSF_READ_AS_INTEGER"],[5,0,1,"","CU_TRSF_SEAMLESS_CUBEMAP"],[5,0,1,"","CU_TRSF_SRGB"],[5,1,1,"","CUaccessPolicyWindow"],[5,1,1,"","CUaccessPolicyWindow_st"],[5,1,1,"","CUaccessPolicyWindow_v1"],[5,1,1,"","CUaccessProperty"],[5,1,1,"","CUaddress_mode"],[5,1,1,"","CUarray"],[5,1,1,"","CUarrayMapInfo"],[5,1,1,"","CUarrayMapInfo_st"],[5,1,1,"","CUarrayMapInfo_v1"],[5,1,1,"","CUarraySparseSubresourceType"],[5,1,1,"","CUarray_cubemap_face"],[5,1,1,"","CUarray_format"],[5,1,1,"","CUclusterSchedulingPolicy"],[5,1,1,"","CUcomputemode"],[5,1,1,"","CUcontext"],[5,1,1,"","CUctx_flags"],[5,1,1,"","CUdevice"],[5,1,1,"","CUdevice_P2PAttribute"],[5,1,1,"","CUdevice_attribute"],[5,1,1,"","CUdevice_v1"],[5,1,1,"","CUdeviceptr"],[5,1,1,"","CUdeviceptr_v2"],[5,1,1,"","CUdevprop"],[5,1,1,"","CUdevprop_st"],[5,1,1,"","CUdevprop_v1"],[5,1,1,"","CUdriverProcAddress_flags"],[5,1,1,"","CUeglColorFormat"],[5,1,1,"","CUeglFrame"],[5,1,1,"","CUeglFrameType"],[5,1,1,"","CUeglFrame_st"],[5,1,1,"","CUeglFrame_v1"],[5,1,1,"","CUeglResourceLocationFlags"],[5,1,1,"","CUeglStreamConnection"],[5,1,1,"","CUevent"],[5,1,1,"","CUevent_flags"],[5,1,1,"","CUevent_record_flags"],[5,1,1,"","CUevent_sched_flags"],[5,1,1,"","CUevent_wait_flags"],[5,1,1,"","CUexecAffinityParam"],[5,1,1,"","CUexecAffinityParam_st"],[5,1,1,"","CUexecAffinityParam_v1"],[5,1,1,"","CUexecAffinitySmCount"],[5,1,1,"","CUexecAffinitySmCount_st"],[5,1,1,"","CUexecAffinitySmCount_v1"],[5,1,1,"","CUexecAffinityType"],[5,1,1,"","CUexternalMemory"],[5,1,1,"","CUexternalMemoryHandleType"],[5,1,1,"","CUexternalSemaphore"],[5,1,1,"","CUexternalSemaphoreHandleType"],[5,1,1,"","CUfilter_mode"],[5,1,1,"","CUflushGPUDirectRDMAWritesOptions"],[5,1,1,"","CUflushGPUDirectRDMAWritesScope"],[5,1,1,"","CUflushGPUDirectRDMAWritesTarget"],[5,1,1,"","CUfunc_cache"],[5,1,1,"","CUfunction"],[5,1,1,"","CUfunction_attribute"],[5,1,1,"","CUgraph"],[5,1,1,"","CUgraphDebugDot_flags"],[5,1,1,"","CUgraphExec"],[5,1,1,"","CUgraphExecUpdateResult"],[5,1,1,"","CUgraphInstantiate_flags"],[5,1,1,"","CUgraphMem_attribute"],[5,1,1,"","CUgraphNode"],[5,1,1,"","CUgraphNodeType"],[5,1,1,"","CUgraphicsMapResourceFlags"],[5,1,1,"","CUgraphicsRegisterFlags"],[5,1,1,"","CUgraphicsResource"],[5,1,1,"","CUhostFn"],[5,1,1,"","CUipcEventHandle"],[5,1,1,"","CUipcEventHandle_st"],[5,1,1,"","CUipcEventHandle_v1"],[5,1,1,"","CUipcMemHandle"],[5,1,1,"","CUipcMemHandle_st"],[5,1,1,"","CUipcMemHandle_v1"],[5,1,1,"","CUipcMem_flags"],[5,1,1,"","CUjitInputType"],[5,1,1,"","CUjit_cacheMode"],[5,1,1,"","CUjit_fallback"],[5,1,1,"","CUjit_option"],[5,1,1,"","CUjit_target"],[5,1,1,"","CUkernelNodeAttrValue"],[5,1,1,"","CUkernelNodeAttrValue_v1"],[5,1,1,"","CUlaunchAttribute"],[5,1,1,"","CUlaunchAttributeValue"],[5,1,1,"","CUlaunchAttributeValue_union"],[5,1,1,"","CUlaunchAttribute_st"],[5,1,1,"","CUlaunchConfig"],[5,1,1,"","CUlaunchConfig_st"],[5,1,1,"","CUlimit"],[5,1,1,"","CUlinkState"],[5,1,1,"","CUmemAccessDesc"],[5,1,1,"","CUmemAccessDesc_st"],[5,1,1,"","CUmemAccessDesc_v1"],[5,1,1,"","CUmemAccess_flags"],[5,1,1,"","CUmemAllocationCompType"],[5,1,1,"","CUmemAllocationGranularity_flags"],[5,1,1,"","CUmemAllocationHandleType"],[5,1,1,"","CUmemAllocationProp"],[5,1,1,"","CUmemAllocationProp_st"],[5,1,1,"","CUmemAllocationProp_v1"],[5,1,1,"","CUmemAllocationType"],[5,1,1,"","CUmemAttach_flags"],[5,1,1,"","CUmemGenericAllocationHandle"],[5,1,1,"","CUmemGenericAllocationHandle_v1"],[5,1,1,"","CUmemHandleType"],[5,1,1,"","CUmemLocation"],[5,1,1,"","CUmemLocationType"],[5,1,1,"","CUmemLocation_st"],[5,1,1,"","CUmemLocation_v1"],[5,1,1,"","CUmemOperationType"],[5,1,1,"","CUmemPoolProps"],[5,1,1,"","CUmemPoolProps_st"],[5,1,1,"","CUmemPoolProps_v1"],[5,1,1,"","CUmemPoolPtrExportData"],[5,1,1,"","CUmemPoolPtrExportData_st"],[5,1,1,"","CUmemPoolPtrExportData_v1"],[5,1,1,"","CUmemPool_attribute"],[5,1,1,"","CUmemRangeHandleType"],[5,1,1,"","CUmem_advise"],[5,1,1,"","CUmem_range_attribute"],[5,1,1,"","CUmemoryPool"],[5,1,1,"","CUmemorytype"],[5,1,1,"","CUmipmappedArray"],[5,1,1,"","CUmodule"],[5,1,1,"","CUmoduleLoadingMode"],[5,1,1,"","CUoccupancyB2DSize"],[5,1,1,"","CUoccupancy_flags"],[5,1,1,"","CUpointer_attribute"],[5,1,1,"","CUresourceViewFormat"],[5,1,1,"","CUresourcetype"],[5,1,1,"","CUresult"],[5,1,1,"","CUshared_carveout"],[5,1,1,"","CUsharedconfig"],[5,1,1,"","CUstream"],[5,1,1,"","CUstreamAttrID"],[5,1,1,"","CUstreamAttrValue"],[5,1,1,"","CUstreamAttrValue_v1"],[5,1,1,"","CUstreamBatchMemOpParams"],[5,1,1,"","CUstreamBatchMemOpParams_union"],[5,1,1,"","CUstreamBatchMemOpParams_v1"],[5,1,1,"","CUstreamBatchMemOpType"],[5,1,1,"","CUstreamCallback"],[5,1,1,"","CUstreamCaptureMode"],[5,1,1,"","CUstreamCaptureStatus"],[5,1,1,"","CUstreamMemoryBarrier_flags"],[5,1,1,"","CUstreamUpdateCaptureDependencies_flags"],[5,1,1,"","CUstreamWaitValue_flags"],[5,1,1,"","CUstreamWriteValue_flags"],[5,1,1,"","CUstream_flags"],[5,1,1,"","CUsurfObject"],[5,1,1,"","CUsurfObject_v1"],[5,1,1,"","CUsurfref"],[5,1,1,"","CUsynchronizationPolicy"],[5,1,1,"","CUtexObject"],[5,1,1,"","CUtexObject_v1"],[5,1,1,"","CUtexref"],[5,1,1,"","CUuserObject"],[5,1,1,"","CUuserObjectRetain_flags"],[5,1,1,"","CUuserObject_flags"],[5,1,1,"","CUuuid"],[5,1,1,"","CUuuid_st"],[5,0,1,"","MAX_PLANES"],[5,1,1,"","cl_context_flags"],[5,1,1,"","cl_event_flags"],[5,3,1,"","cuArray3DCreate"],[5,3,1,"","cuArray3DGetDescriptor"],[5,3,1,"","cuArrayCreate"],[5,3,1,"","cuArrayDestroy"],[5,3,1,"","cuArrayGetDescriptor"],[5,3,1,"","cuArrayGetMemoryRequirements"],[5,3,1,"","cuArrayGetPlane"],[5,3,1,"","cuArrayGetSparseProperties"],[5,3,1,"","cuCtxCreate"],[5,3,1,"","cuCtxCreate_v3"],[5,3,1,"","cuCtxDestroy"],[5,3,1,"","cuCtxDisablePeerAccess"],[5,3,1,"","cuCtxEnablePeerAccess"],[5,3,1,"","cuCtxGetApiVersion"],[5,3,1,"","cuCtxGetCacheConfig"],[5,3,1,"","cuCtxGetCurrent"],[5,3,1,"","cuCtxGetDevice"],[5,3,1,"","cuCtxGetExecAffinity"],[5,3,1,"","cuCtxGetFlags"],[5,3,1,"","cuCtxGetLimit"],[5,3,1,"","cuCtxGetSharedMemConfig"],[5,3,1,"","cuCtxGetStreamPriorityRange"],[5,3,1,"","cuCtxPopCurrent"],[5,3,1,"","cuCtxPushCurrent"],[5,3,1,"","cuCtxResetPersistingL2Cache"],[5,3,1,"","cuCtxSetCacheConfig"],[5,3,1,"","cuCtxSetCurrent"],[5,3,1,"","cuCtxSetLimit"],[5,3,1,"","cuCtxSetSharedMemConfig"],[5,3,1,"","cuCtxSynchronize"],[5,3,1,"","cuDestroyExternalMemory"],[5,3,1,"","cuDestroyExternalSemaphore"],[5,3,1,"","cuDeviceCanAccessPeer"],[5,3,1,"","cuDeviceGet"],[5,3,1,"","cuDeviceGetAttribute"],[5,3,1,"","cuDeviceGetByPCIBusId"],[5,3,1,"","cuDeviceGetCount"],[5,3,1,"","cuDeviceGetDefaultMemPool"],[5,3,1,"","cuDeviceGetGraphMemAttribute"],[5,3,1,"","cuDeviceGetLuid"],[5,3,1,"","cuDeviceGetMemPool"],[5,3,1,"","cuDeviceGetName"],[5,3,1,"","cuDeviceGetNvSciSyncAttributes"],[5,3,1,"","cuDeviceGetP2PAttribute"],[5,3,1,"","cuDeviceGetPCIBusId"],[5,3,1,"","cuDeviceGetTexture1DLinearMaxWidth"],[5,3,1,"","cuDeviceGetUuid"],[5,3,1,"","cuDeviceGetUuid_v2"],[5,3,1,"","cuDeviceGraphMemTrim"],[5,3,1,"","cuDevicePrimaryCtxGetState"],[5,3,1,"","cuDevicePrimaryCtxRelease"],[5,3,1,"","cuDevicePrimaryCtxReset"],[5,3,1,"","cuDevicePrimaryCtxRetain"],[5,3,1,"","cuDevicePrimaryCtxSetFlags"],[5,3,1,"","cuDeviceSetGraphMemAttribute"],[5,3,1,"","cuDeviceSetMemPool"],[5,3,1,"","cuDeviceTotalMem"],[5,3,1,"","cuDriverGetVersion"],[5,3,1,"","cuEGLStreamConsumerAcquireFrame"],[5,3,1,"","cuEGLStreamConsumerConnect"],[5,3,1,"","cuEGLStreamConsumerConnectWithFlags"],[5,3,1,"","cuEGLStreamConsumerDisconnect"],[5,3,1,"","cuEGLStreamConsumerReleaseFrame"],[5,3,1,"","cuEGLStreamProducerConnect"],[5,3,1,"","cuEGLStreamProducerDisconnect"],[5,3,1,"","cuEGLStreamProducerPresentFrame"],[5,3,1,"","cuEGLStreamProducerReturnFrame"],[5,3,1,"","cuEventCreate"],[5,3,1,"","cuEventCreateFromEGLSync"],[5,3,1,"","cuEventDestroy"],[5,3,1,"","cuEventElapsedTime"],[5,3,1,"","cuEventQuery"],[5,3,1,"","cuEventRecord"],[5,3,1,"","cuEventRecordWithFlags"],[5,3,1,"","cuEventSynchronize"],[5,3,1,"","cuExternalMemoryGetMappedBuffer"],[5,3,1,"","cuExternalMemoryGetMappedMipmappedArray"],[5,3,1,"","cuFlushGPUDirectRDMAWrites"],[5,3,1,"","cuFuncGetAttribute"],[5,3,1,"","cuFuncGetModule"],[5,3,1,"","cuFuncSetAttribute"],[5,3,1,"","cuFuncSetCacheConfig"],[5,3,1,"","cuFuncSetSharedMemConfig"],[5,3,1,"","cuGLGetDevices"],[5,3,1,"","cuGetErrorName"],[5,3,1,"","cuGetErrorString"],[5,3,1,"","cuGetProcAddress"],[5,3,1,"","cuGraphAddBatchMemOpNode"],[5,3,1,"","cuGraphAddChildGraphNode"],[5,3,1,"","cuGraphAddDependencies"],[5,3,1,"","cuGraphAddEmptyNode"],[5,3,1,"","cuGraphAddEventRecordNode"],[5,3,1,"","cuGraphAddEventWaitNode"],[5,3,1,"","cuGraphAddExternalSemaphoresSignalNode"],[5,3,1,"","cuGraphAddExternalSemaphoresWaitNode"],[5,3,1,"","cuGraphAddHostNode"],[5,3,1,"","cuGraphAddKernelNode"],[5,3,1,"","cuGraphAddMemAllocNode"],[5,3,1,"","cuGraphAddMemFreeNode"],[5,3,1,"","cuGraphAddMemcpyNode"],[5,3,1,"","cuGraphAddMemsetNode"],[5,3,1,"","cuGraphBatchMemOpNodeGetParams"],[5,3,1,"","cuGraphBatchMemOpNodeSetParams"],[5,3,1,"","cuGraphChildGraphNodeGetGraph"],[5,3,1,"","cuGraphClone"],[5,3,1,"","cuGraphCreate"],[5,3,1,"","cuGraphDebugDotPrint"],[5,3,1,"","cuGraphDestroy"],[5,3,1,"","cuGraphDestroyNode"],[5,3,1,"","cuGraphEventRecordNodeGetEvent"],[5,3,1,"","cuGraphEventRecordNodeSetEvent"],[5,3,1,"","cuGraphEventWaitNodeGetEvent"],[5,3,1,"","cuGraphEventWaitNodeSetEvent"],[5,3,1,"","cuGraphExecBatchMemOpNodeSetParams"],[5,3,1,"","cuGraphExecChildGraphNodeSetParams"],[5,3,1,"","cuGraphExecDestroy"],[5,3,1,"","cuGraphExecEventRecordNodeSetEvent"],[5,3,1,"","cuGraphExecEventWaitNodeSetEvent"],[5,3,1,"","cuGraphExecExternalSemaphoresSignalNodeSetParams"],[5,3,1,"","cuGraphExecExternalSemaphoresWaitNodeSetParams"],[5,3,1,"","cuGraphExecHostNodeSetParams"],[5,3,1,"","cuGraphExecKernelNodeSetParams"],[5,3,1,"","cuGraphExecMemcpyNodeSetParams"],[5,3,1,"","cuGraphExecMemsetNodeSetParams"],[5,3,1,"","cuGraphExecUpdate"],[5,3,1,"","cuGraphExternalSemaphoresSignalNodeGetParams"],[5,3,1,"","cuGraphExternalSemaphoresSignalNodeSetParams"],[5,3,1,"","cuGraphExternalSemaphoresWaitNodeGetParams"],[5,3,1,"","cuGraphExternalSemaphoresWaitNodeSetParams"],[5,3,1,"","cuGraphGetEdges"],[5,3,1,"","cuGraphGetNodes"],[5,3,1,"","cuGraphGetRootNodes"],[5,3,1,"","cuGraphHostNodeGetParams"],[5,3,1,"","cuGraphHostNodeSetParams"],[5,3,1,"","cuGraphInstantiate"],[5,3,1,"","cuGraphInstantiateWithFlags"],[5,3,1,"","cuGraphKernelNodeCopyAttributes"],[5,3,1,"","cuGraphKernelNodeGetAttribute"],[5,3,1,"","cuGraphKernelNodeGetParams"],[5,3,1,"","cuGraphKernelNodeSetAttribute"],[5,3,1,"","cuGraphKernelNodeSetParams"],[5,3,1,"","cuGraphLaunch"],[5,3,1,"","cuGraphMemAllocNodeGetParams"],[5,3,1,"","cuGraphMemFreeNodeGetParams"],[5,3,1,"","cuGraphMemcpyNodeGetParams"],[5,3,1,"","cuGraphMemcpyNodeSetParams"],[5,3,1,"","cuGraphMemsetNodeGetParams"],[5,3,1,"","cuGraphMemsetNodeSetParams"],[5,3,1,"","cuGraphNodeFindInClone"],[5,3,1,"","cuGraphNodeGetDependencies"],[5,3,1,"","cuGraphNodeGetDependentNodes"],[5,3,1,"","cuGraphNodeGetEnabled"],[5,3,1,"","cuGraphNodeGetType"],[5,3,1,"","cuGraphNodeSetEnabled"],[5,3,1,"","cuGraphReleaseUserObject"],[5,3,1,"","cuGraphRemoveDependencies"],[5,3,1,"","cuGraphRetainUserObject"],[5,3,1,"","cuGraphUpload"],[5,3,1,"","cuGraphicsEGLRegisterImage"],[5,3,1,"","cuGraphicsGLRegisterBuffer"],[5,3,1,"","cuGraphicsGLRegisterImage"],[5,3,1,"","cuGraphicsMapResources"],[5,3,1,"","cuGraphicsResourceGetMappedEglFrame"],[5,3,1,"","cuGraphicsResourceGetMappedMipmappedArray"],[5,3,1,"","cuGraphicsResourceGetMappedPointer"],[5,3,1,"","cuGraphicsResourceSetMapFlags"],[5,3,1,"","cuGraphicsSubResourceGetMappedArray"],[5,3,1,"","cuGraphicsUnmapResources"],[5,3,1,"","cuGraphicsUnregisterResource"],[5,3,1,"","cuGraphicsVDPAURegisterOutputSurface"],[5,3,1,"","cuGraphicsVDPAURegisterVideoSurface"],[5,3,1,"","cuImportExternalMemory"],[5,3,1,"","cuImportExternalSemaphore"],[5,3,1,"","cuInit"],[5,3,1,"","cuIpcCloseMemHandle"],[5,3,1,"","cuIpcGetEventHandle"],[5,3,1,"","cuIpcGetMemHandle"],[5,3,1,"","cuIpcOpenEventHandle"],[5,3,1,"","cuIpcOpenMemHandle"],[5,3,1,"","cuLaunchCooperativeKernel"],[5,3,1,"","cuLaunchCooperativeKernelMultiDevice"],[5,3,1,"","cuLaunchHostFunc"],[5,3,1,"","cuLaunchKernel"],[5,3,1,"","cuLaunchKernelEx"],[5,3,1,"","cuLinkAddData"],[5,3,1,"","cuLinkAddFile"],[5,3,1,"","cuLinkComplete"],[5,3,1,"","cuLinkCreate"],[5,3,1,"","cuLinkDestroy"],[5,3,1,"","cuMemAddressFree"],[5,3,1,"","cuMemAddressReserve"],[5,3,1,"","cuMemAdvise"],[5,3,1,"","cuMemAlloc"],[5,3,1,"","cuMemAllocAsync"],[5,3,1,"","cuMemAllocFromPoolAsync"],[5,3,1,"","cuMemAllocHost"],[5,3,1,"","cuMemAllocManaged"],[5,3,1,"","cuMemAllocPitch"],[5,3,1,"","cuMemCreate"],[5,3,1,"","cuMemExportToShareableHandle"],[5,3,1,"","cuMemFree"],[5,3,1,"","cuMemFreeAsync"],[5,3,1,"","cuMemFreeHost"],[5,3,1,"","cuMemGetAccess"],[5,3,1,"","cuMemGetAddressRange"],[5,3,1,"","cuMemGetAllocationGranularity"],[5,3,1,"","cuMemGetAllocationPropertiesFromHandle"],[5,3,1,"","cuMemGetHandleForAddressRange"],[5,3,1,"","cuMemGetInfo"],[5,3,1,"","cuMemHostAlloc"],[5,3,1,"","cuMemHostGetDevicePointer"],[5,3,1,"","cuMemHostGetFlags"],[5,3,1,"","cuMemHostRegister"],[5,3,1,"","cuMemHostUnregister"],[5,3,1,"","cuMemImportFromShareableHandle"],[5,3,1,"","cuMemMap"],[5,3,1,"","cuMemMapArrayAsync"],[5,3,1,"","cuMemPoolCreate"],[5,3,1,"","cuMemPoolDestroy"],[5,3,1,"","cuMemPoolExportPointer"],[5,3,1,"","cuMemPoolExportToShareableHandle"],[5,3,1,"","cuMemPoolGetAccess"],[5,3,1,"","cuMemPoolGetAttribute"],[5,3,1,"","cuMemPoolImportFromShareableHandle"],[5,3,1,"","cuMemPoolImportPointer"],[5,3,1,"","cuMemPoolSetAccess"],[5,3,1,"","cuMemPoolSetAttribute"],[5,3,1,"","cuMemPoolTrimTo"],[5,3,1,"","cuMemPrefetchAsync"],[5,3,1,"","cuMemRangeGetAttribute"],[5,3,1,"","cuMemRangeGetAttributes"],[5,3,1,"","cuMemRelease"],[5,3,1,"","cuMemRetainAllocationHandle"],[5,3,1,"","cuMemSetAccess"],[5,3,1,"","cuMemUnmap"],[5,3,1,"","cuMemcpy"],[5,3,1,"","cuMemcpy2D"],[5,3,1,"","cuMemcpy2DAsync"],[5,3,1,"","cuMemcpy2DUnaligned"],[5,3,1,"","cuMemcpy3D"],[5,3,1,"","cuMemcpy3DAsync"],[5,3,1,"","cuMemcpy3DPeer"],[5,3,1,"","cuMemcpy3DPeerAsync"],[5,3,1,"","cuMemcpyAsync"],[5,3,1,"","cuMemcpyAtoA"],[5,3,1,"","cuMemcpyAtoD"],[5,3,1,"","cuMemcpyAtoH"],[5,3,1,"","cuMemcpyAtoHAsync"],[5,3,1,"","cuMemcpyDtoA"],[5,3,1,"","cuMemcpyDtoD"],[5,3,1,"","cuMemcpyDtoDAsync"],[5,3,1,"","cuMemcpyDtoH"],[5,3,1,"","cuMemcpyDtoHAsync"],[5,3,1,"","cuMemcpyHtoA"],[5,3,1,"","cuMemcpyHtoAAsync"],[5,3,1,"","cuMemcpyHtoD"],[5,3,1,"","cuMemcpyHtoDAsync"],[5,3,1,"","cuMemcpyPeer"],[5,3,1,"","cuMemcpyPeerAsync"],[5,3,1,"","cuMemsetD16"],[5,3,1,"","cuMemsetD16Async"],[5,3,1,"","cuMemsetD2D16"],[5,3,1,"","cuMemsetD2D16Async"],[5,3,1,"","cuMemsetD2D32"],[5,3,1,"","cuMemsetD2D32Async"],[5,3,1,"","cuMemsetD2D8"],[5,3,1,"","cuMemsetD2D8Async"],[5,3,1,"","cuMemsetD32"],[5,3,1,"","cuMemsetD32Async"],[5,3,1,"","cuMemsetD8"],[5,3,1,"","cuMemsetD8Async"],[5,3,1,"","cuMipmappedArrayCreate"],[5,3,1,"","cuMipmappedArrayDestroy"],[5,3,1,"","cuMipmappedArrayGetLevel"],[5,3,1,"","cuMipmappedArrayGetMemoryRequirements"],[5,3,1,"","cuMipmappedArrayGetSparseProperties"],[5,3,1,"","cuModuleGetFunction"],[5,3,1,"","cuModuleGetGlobal"],[5,3,1,"","cuModuleGetLoadingMode"],[5,3,1,"","cuModuleGetSurfRef"],[5,3,1,"","cuModuleGetTexRef"],[5,3,1,"","cuModuleLoad"],[5,3,1,"","cuModuleLoadData"],[5,3,1,"","cuModuleLoadDataEx"],[5,3,1,"","cuModuleLoadFatBinary"],[5,3,1,"","cuModuleUnload"],[5,3,1,"","cuOccupancyAvailableDynamicSMemPerBlock"],[5,3,1,"","cuOccupancyMaxActiveBlocksPerMultiprocessor"],[5,3,1,"","cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"],[5,3,1,"","cuOccupancyMaxActiveClusters"],[5,3,1,"","cuOccupancyMaxPotentialBlockSize"],[5,3,1,"","cuOccupancyMaxPotentialBlockSizeWithFlags"],[5,3,1,"","cuOccupancyMaxPotentialClusterSize"],[5,3,1,"","cuPointerGetAttribute"],[5,3,1,"","cuPointerGetAttributes"],[5,3,1,"","cuPointerSetAttribute"],[5,3,1,"","cuProfilerStart"],[5,3,1,"","cuProfilerStop"],[5,3,1,"","cuSignalExternalSemaphoresAsync"],[5,3,1,"","cuStreamAddCallback"],[5,3,1,"","cuStreamAttachMemAsync"],[5,3,1,"","cuStreamBatchMemOp"],[5,3,1,"","cuStreamBatchMemOp_v2"],[5,3,1,"","cuStreamBeginCapture"],[5,3,1,"","cuStreamCopyAttributes"],[5,3,1,"","cuStreamCreate"],[5,3,1,"","cuStreamCreateWithPriority"],[5,3,1,"","cuStreamDestroy"],[5,3,1,"","cuStreamEndCapture"],[5,3,1,"","cuStreamGetAttribute"],[5,3,1,"","cuStreamGetCaptureInfo"],[5,3,1,"","cuStreamGetCaptureInfo_v2"],[5,3,1,"","cuStreamGetCtx"],[5,3,1,"","cuStreamGetFlags"],[5,3,1,"","cuStreamGetPriority"],[5,3,1,"","cuStreamIsCapturing"],[5,3,1,"","cuStreamQuery"],[5,3,1,"","cuStreamSetAttribute"],[5,3,1,"","cuStreamSynchronize"],[5,3,1,"","cuStreamUpdateCaptureDependencies"],[5,3,1,"","cuStreamWaitEvent"],[5,3,1,"","cuStreamWaitValue32"],[5,3,1,"","cuStreamWaitValue32_v2"],[5,3,1,"","cuStreamWaitValue64"],[5,3,1,"","cuStreamWaitValue64_v2"],[5,3,1,"","cuStreamWriteValue32"],[5,3,1,"","cuStreamWriteValue32_v2"],[5,3,1,"","cuStreamWriteValue64"],[5,3,1,"","cuStreamWriteValue64_v2"],[5,3,1,"","cuSurfObjectCreate"],[5,3,1,"","cuSurfObjectDestroy"],[5,3,1,"","cuSurfObjectGetResourceDesc"],[5,3,1,"","cuTexObjectCreate"],[5,3,1,"","cuTexObjectDestroy"],[5,3,1,"","cuTexObjectGetResourceDesc"],[5,3,1,"","cuTexObjectGetResourceViewDesc"],[5,3,1,"","cuTexObjectGetTextureDesc"],[5,3,1,"","cuThreadExchangeStreamCaptureMode"],[5,3,1,"","cuUserObjectCreate"],[5,3,1,"","cuUserObjectRelease"],[5,3,1,"","cuUserObjectRetain"],[5,3,1,"","cuVDPAUCtxCreate"],[5,3,1,"","cuVDPAUGetDevice"],[5,3,1,"","cuWaitExternalSemaphoresAsync"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR_st":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY3D_DESCRIPTOR_v2":[[5,0,1,"","Depth"],[5,0,1,"","Flags"],[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR_st":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_DESCRIPTOR_v2":[[5,0,1,"","Format"],[5,0,1,"","Height"],[5,0,1,"","NumChannels"],[5,0,1,"","Width"],[5,2,1,"","getPtr"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_st":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_MEMORY_REQUIREMENTS_v1":[[5,0,1,"","alignment"],[5,2,1,"","getPtr"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_ARRAY_SPARSE_PROPERTIES_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","miptailFirstLevel"],[5,0,1,"","miptailSize"],[5,0,1,"","reserved"],[5,0,1,"","tileExtent"]],"cuda.cuda.CUDA_BATCH_MEM_OP_NODE_PARAMS":[[5,0,1,"","count"],[5,0,1,"","ctx"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","paramArray"]],"cuda.cuda.CUDA_BATCH_MEM_OP_NODE_PARAMS_st":[[5,0,1,"","count"],[5,0,1,"","ctx"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","paramArray"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","size"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","size"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1":[[5,0,1,"","arrayDesc"],[5,2,1,"","getPtr"],[5,0,1,"","numLevels"],[5,0,1,"","offset"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","handle"],[5,0,1,"","reserved"],[5,0,1,"","type"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","params"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1":[[5,0,1,"","extSemArray"],[5,2,1,"","getPtr"],[5,0,1,"","numExtSems"],[5,0,1,"","paramsArray"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS_st":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_HOST_NODE_PARAMS_v1":[[5,0,1,"","fn"],[5,2,1,"","getPtr"],[5,0,1,"","userData"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS_st":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_KERNEL_NODE_PARAMS_v1":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","extra"],[5,0,1,"","func"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS_st":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_LAUNCH_PARAMS_v1":[[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,0,1,"","function"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","kernelParams"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUDA_MEMCPY2D":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY2D_st":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY2D_v2":[[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHost"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHost"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"]],"cuda.cuda.CUDA_MEMCPY3D":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER_st":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_PEER_v1":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstContext"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","srcArray"],[5,0,1,"","srcContext"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_st":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMCPY3D_v2":[[5,0,1,"","Depth"],[5,0,1,"","Height"],[5,0,1,"","WidthInBytes"],[5,0,1,"","dstArray"],[5,0,1,"","dstDevice"],[5,0,1,"","dstHeight"],[5,0,1,"","dstHost"],[5,0,1,"","dstLOD"],[5,0,1,"","dstMemoryType"],[5,0,1,"","dstPitch"],[5,0,1,"","dstXInBytes"],[5,0,1,"","dstY"],[5,0,1,"","dstZ"],[5,2,1,"","getPtr"],[5,0,1,"","reserved0"],[5,0,1,"","reserved1"],[5,0,1,"","srcArray"],[5,0,1,"","srcDevice"],[5,0,1,"","srcHeight"],[5,0,1,"","srcHost"],[5,0,1,"","srcLOD"],[5,0,1,"","srcMemoryType"],[5,0,1,"","srcPitch"],[5,0,1,"","srcXInBytes"],[5,0,1,"","srcY"],[5,0,1,"","srcZ"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS_st":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEMSET_NODE_PARAMS_v1":[[5,0,1,"","dst"],[5,0,1,"","elementSize"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","pitch"],[5,0,1,"","value"],[5,0,1,"","width"]],"cuda.cuda.CUDA_MEM_ALLOC_NODE_PARAMS":[[5,0,1,"","accessDescCount"],[5,0,1,"","accessDescs"],[5,0,1,"","bytesize"],[5,0,1,"","dptr"],[5,2,1,"","getPtr"],[5,0,1,"","poolProps"]],"cuda.cuda.CUDA_MEM_ALLOC_NODE_PARAMS_st":[[5,0,1,"","accessDescCount"],[5,0,1,"","accessDescs"],[5,0,1,"","bytesize"],[5,0,1,"","dptr"],[5,2,1,"","getPtr"],[5,0,1,"","poolProps"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS":[[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1":[[5,2,1,"","getPtr"],[5,0,1,"","p2pToken"],[5,0,1,"","vaSpaceToken"]],"cuda.cuda.CUDA_RESOURCE_DESC":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_DESC_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_DESC_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","res"],[5,0,1,"","resType"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC_st":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_RESOURCE_VIEW_DESC_v1":[[5,0,1,"","depth"],[5,0,1,"","firstLayer"],[5,0,1,"","firstMipmapLevel"],[5,0,1,"","format"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","lastLayer"],[5,0,1,"","lastMipmapLevel"],[5,0,1,"","reserved"],[5,0,1,"","width"]],"cuda.cuda.CUDA_TEXTURE_DESC":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_TEXTURE_DESC_st":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUDA_TEXTURE_DESC_v1":[[5,0,1,"","addressMode"],[5,0,1,"","borderColor"],[5,0,1,"","filterMode"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","maxAnisotropy"],[5,0,1,"","maxMipmapLevelClamp"],[5,0,1,"","minMipmapLevelClamp"],[5,0,1,"","mipmapFilterMode"],[5,0,1,"","mipmapLevelBias"],[5,0,1,"","reserved"]],"cuda.cuda.CUGLDeviceList":[[5,0,1,"","CU_GL_DEVICE_LIST_ALL"],[5,0,1,"","CU_GL_DEVICE_LIST_CURRENT_FRAME"],[5,0,1,"","CU_GL_DEVICE_LIST_NEXT_FRAME"]],"cuda.cuda.CUGPUDirectRDMAWritesOrdering":[[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES"],[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE"],[5,0,1,"","CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER"]],"cuda.cuda.CUaccessPolicyWindow":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessPolicyWindow_st":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessPolicyWindow_v1":[[5,0,1,"","base_ptr"],[5,2,1,"","getPtr"],[5,0,1,"","hitProp"],[5,0,1,"","hitRatio"],[5,0,1,"","missProp"],[5,0,1,"","num_bytes"]],"cuda.cuda.CUaccessProperty":[[5,0,1,"","CU_ACCESS_PROPERTY_NORMAL"],[5,0,1,"","CU_ACCESS_PROPERTY_PERSISTING"],[5,0,1,"","CU_ACCESS_PROPERTY_STREAMING"]],"cuda.cuda.CUaddress_mode":[[5,0,1,"","CU_TR_ADDRESS_MODE_BORDER"],[5,0,1,"","CU_TR_ADDRESS_MODE_CLAMP"],[5,0,1,"","CU_TR_ADDRESS_MODE_MIRROR"],[5,0,1,"","CU_TR_ADDRESS_MODE_WRAP"]],"cuda.cuda.CUarray":[[5,2,1,"","getPtr"]],"cuda.cuda.CUarrayMapInfo":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarrayMapInfo_st":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarrayMapInfo_v1":[[5,0,1,"","deviceBitMask"],[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","memHandle"],[5,0,1,"","memHandleType"],[5,0,1,"","memOperationType"],[5,0,1,"","offset"],[5,0,1,"","reserved"],[5,0,1,"","resource"],[5,0,1,"","resourceType"],[5,0,1,"","subresource"],[5,0,1,"","subresourceType"]],"cuda.cuda.CUarraySparseSubresourceType":[[5,0,1,"","CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL"],[5,0,1,"","CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL"]],"cuda.cuda.CUarray_cubemap_face":[[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_X"],[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_Y"],[5,0,1,"","CU_CUBEMAP_FACE_NEGATIVE_Z"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_X"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_Y"],[5,0,1,"","CU_CUBEMAP_FACE_POSITIVE_Z"]],"cuda.cuda.CUarray_format":[[5,0,1,"","CU_AD_FORMAT_BC1_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC1_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC2_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC2_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC3_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC3_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_BC4_SNORM"],[5,0,1,"","CU_AD_FORMAT_BC4_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC5_SNORM"],[5,0,1,"","CU_AD_FORMAT_BC5_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC6H_SF16"],[5,0,1,"","CU_AD_FORMAT_BC6H_UF16"],[5,0,1,"","CU_AD_FORMAT_BC7_UNORM"],[5,0,1,"","CU_AD_FORMAT_BC7_UNORM_SRGB"],[5,0,1,"","CU_AD_FORMAT_FLOAT"],[5,0,1,"","CU_AD_FORMAT_HALF"],[5,0,1,"","CU_AD_FORMAT_NV12"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT16"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT32"],[5,0,1,"","CU_AD_FORMAT_SIGNED_INT8"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X1"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X2"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT16X4"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X1"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X2"],[5,0,1,"","CU_AD_FORMAT_SNORM_INT8X4"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X1"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X2"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT16X4"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X1"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X2"],[5,0,1,"","CU_AD_FORMAT_UNORM_INT8X4"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT16"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT32"],[5,0,1,"","CU_AD_FORMAT_UNSIGNED_INT8"]],"cuda.cuda.CUclusterSchedulingPolicy":[[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_DEFAULT"],[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING"],[5,0,1,"","CU_CLUSTER_SCHEDULING_POLICY_SPREAD"]],"cuda.cuda.CUcomputemode":[[5,0,1,"","CU_COMPUTEMODE_DEFAULT"],[5,0,1,"","CU_COMPUTEMODE_EXCLUSIVE_PROCESS"],[5,0,1,"","CU_COMPUTEMODE_PROHIBITED"]],"cuda.cuda.CUcontext":[[5,2,1,"","getPtr"]],"cuda.cuda.CUctx_flags":[[5,0,1,"","CU_CTX_BLOCKING_SYNC"],[5,0,1,"","CU_CTX_FLAGS_MASK"],[5,0,1,"","CU_CTX_LMEM_RESIZE_TO_MAX"],[5,0,1,"","CU_CTX_MAP_HOST"],[5,0,1,"","CU_CTX_SCHED_AUTO"],[5,0,1,"","CU_CTX_SCHED_BLOCKING_SYNC"],[5,0,1,"","CU_CTX_SCHED_MASK"],[5,0,1,"","CU_CTX_SCHED_SPIN"],[5,0,1,"","CU_CTX_SCHED_YIELD"]],"cuda.cuda.CUdevice":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdevice_P2PAttribute":[[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED"],[5,0,1,"","CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK"]],"cuda.cuda.CUdevice_attribute":[[5,0,1,"","CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CLOCK_RATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_MODE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_ECC_ENABLED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_GPU_OVERLAP"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_INTEGRATED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_PITCH"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_BUS_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TCC_DRIVER"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED"],[5,0,1,"","CU_DEVICE_ATTRIBUTE_WARP_SIZE"]],"cuda.cuda.CUdevice_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdeviceptr":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdeviceptr_v2":[[5,2,1,"","getPtr"]],"cuda.cuda.CUdevprop":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdevprop_st":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdevprop_v1":[[5,0,1,"","SIMDWidth"],[5,0,1,"","clockRate"],[5,2,1,"","getPtr"],[5,0,1,"","maxGridSize"],[5,0,1,"","maxThreadsDim"],[5,0,1,"","maxThreadsPerBlock"],[5,0,1,"","memPitch"],[5,0,1,"","regsPerBlock"],[5,0,1,"","sharedMemPerBlock"],[5,0,1,"","textureAlign"],[5,0,1,"","totalConstantMemory"]],"cuda.cuda.CUdriverProcAddress_flags":[[5,0,1,"","CU_GET_PROC_ADDRESS_DEFAULT"],[5,0,1,"","CU_GET_PROC_ADDRESS_LEGACY_STREAM"],[5,0,1,"","CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM"]],"cuda.cuda.CUeglColorFormat":[[5,0,1,"","CU_EGL_COLOR_FORMAT_A"],[5,0,1,"","CU_EGL_COLOR_FORMAT_ABGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_ARGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_AYUV"],[5,0,1,"","CU_EGL_COLOR_FORMAT_AYUV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_CCCC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER10_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_BCCR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CBRC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CCCC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_CRBC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_RCCB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER12_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER14_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER20_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_BCCR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_CBRC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_CRBC"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_RCCB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BAYER_RGGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BGR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_BGRA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_L"],[5,0,1,"","CU_EGL_COLOR_FORMAT_MAX"],[5,0,1,"","CU_EGL_COLOR_FORMAT_R"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RG"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RGB"],[5,0,1,"","CU_EGL_COLOR_FORMAT_RGBA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_UYVY_422"],[5,0,1,"","CU_EGL_COLOR_FORMAT_UYVY_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_VYUY"],[5,0,1,"","CU_EGL_COLOR_FORMAT_VYUY_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y10_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y12_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUVA"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUVA_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUYV_422"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YUYV_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_PLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVYU"],[5,0,1,"","CU_EGL_COLOR_FORMAT_YVYU_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y_709_ER"],[5,0,1,"","CU_EGL_COLOR_FORMAT_Y_ER"]],"cuda.cuda.CUeglFrame":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglFrameType":[[5,0,1,"","CU_EGL_FRAME_TYPE_ARRAY"],[5,0,1,"","CU_EGL_FRAME_TYPE_PITCH"]],"cuda.cuda.CUeglFrame_st":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglFrame_v1":[[5,0,1,"","cuFormat"],[5,0,1,"","depth"],[5,0,1,"","eglColorFormat"],[5,0,1,"","frame"],[5,0,1,"","frameType"],[5,2,1,"","getPtr"],[5,0,1,"","height"],[5,0,1,"","numChannels"],[5,0,1,"","pitch"],[5,0,1,"","planeCount"],[5,0,1,"","width"]],"cuda.cuda.CUeglResourceLocationFlags":[[5,0,1,"","CU_EGL_RESOURCE_LOCATION_SYSMEM"],[5,0,1,"","CU_EGL_RESOURCE_LOCATION_VIDMEM"]],"cuda.cuda.CUeglStreamConnection":[[5,2,1,"","getPtr"]],"cuda.cuda.CUevent":[[5,2,1,"","getPtr"]],"cuda.cuda.CUevent_flags":[[5,0,1,"","CU_EVENT_BLOCKING_SYNC"],[5,0,1,"","CU_EVENT_DEFAULT"],[5,0,1,"","CU_EVENT_DISABLE_TIMING"],[5,0,1,"","CU_EVENT_INTERPROCESS"]],"cuda.cuda.CUevent_record_flags":[[5,0,1,"","CU_EVENT_RECORD_DEFAULT"],[5,0,1,"","CU_EVENT_RECORD_EXTERNAL"]],"cuda.cuda.CUevent_sched_flags":[[5,0,1,"","CU_EVENT_SCHED_AUTO"],[5,0,1,"","CU_EVENT_SCHED_BLOCKING_SYNC"],[5,0,1,"","CU_EVENT_SCHED_SPIN"],[5,0,1,"","CU_EVENT_SCHED_YIELD"]],"cuda.cuda.CUevent_wait_flags":[[5,0,1,"","CU_EVENT_WAIT_DEFAULT"],[5,0,1,"","CU_EVENT_WAIT_EXTERNAL"]],"cuda.cuda.CUexecAffinityParam":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinityParam_st":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinityParam_v1":[[5,2,1,"","getPtr"],[5,0,1,"","param"],[5,0,1,"","type"]],"cuda.cuda.CUexecAffinitySmCount":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinitySmCount_st":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinitySmCount_v1":[[5,2,1,"","getPtr"],[5,0,1,"","val"]],"cuda.cuda.CUexecAffinityType":[[5,0,1,"","CU_EXEC_AFFINITY_TYPE_MAX"],[5,0,1,"","CU_EXEC_AFFINITY_TYPE_SM_COUNT"]],"cuda.cuda.CUexternalMemory":[[5,2,1,"","getPtr"]],"cuda.cuda.CUexternalMemoryHandleType":[[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32"],[5,0,1,"","CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT"]],"cuda.cuda.CUexternalSemaphore":[[5,2,1,"","getPtr"]],"cuda.cuda.CUexternalSemaphoreHandleType":[[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD"],[5,0,1,"","CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32"]],"cuda.cuda.CUfilter_mode":[[5,0,1,"","CU_TR_FILTER_MODE_LINEAR"],[5,0,1,"","CU_TR_FILTER_MODE_POINT"]],"cuda.cuda.CUflushGPUDirectRDMAWritesOptions":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST"],[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS"]],"cuda.cuda.CUflushGPUDirectRDMAWritesScope":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES"],[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER"]],"cuda.cuda.CUflushGPUDirectRDMAWritesTarget":[[5,0,1,"","CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX"]],"cuda.cuda.CUfunc_cache":[[5,0,1,"","CU_FUNC_CACHE_PREFER_EQUAL"],[5,0,1,"","CU_FUNC_CACHE_PREFER_L1"],[5,0,1,"","CU_FUNC_CACHE_PREFER_NONE"],[5,0,1,"","CU_FUNC_CACHE_PREFER_SHARED"]],"cuda.cuda.CUfunction":[[5,2,1,"","getPtr"]],"cuda.cuda.CUfunction_attribute":[[5,0,1,"","CU_FUNC_ATTRIBUTE_BINARY_VERSION"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CACHE_MODE_CA"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET"],[5,0,1,"","CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES"],[5,0,1,"","CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK"],[5,0,1,"","CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED"],[5,0,1,"","CU_FUNC_ATTRIBUTE_NUM_REGS"],[5,0,1,"","CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT"],[5,0,1,"","CU_FUNC_ATTRIBUTE_PTX_VERSION"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT"],[5,0,1,"","CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH"],[5,0,1,"","CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES"]],"cuda.cuda.CUgraph":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphDebugDot_flags":[[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES"],[5,0,1,"","CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE"]],"cuda.cuda.CUgraphExec":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphExecUpdateResult":[[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE"],[5,0,1,"","CU_GRAPH_EXEC_UPDATE_SUCCESS"]],"cuda.cuda.CUgraphInstantiate_flags":[[5,0,1,"","CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH"],[5,0,1,"","CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY"]],"cuda.cuda.CUgraphMem_attribute":[[5,0,1,"","CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT"],[5,0,1,"","CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH"],[5,0,1,"","CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT"],[5,0,1,"","CU_GRAPH_MEM_ATTR_USED_MEM_HIGH"]],"cuda.cuda.CUgraphNode":[[5,2,1,"","getPtr"]],"cuda.cuda.CUgraphNodeType":[[5,0,1,"","CU_GRAPH_NODE_TYPE_BATCH_MEM_OP"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EMPTY"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EVENT_RECORD"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL"],[5,0,1,"","CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT"],[5,0,1,"","CU_GRAPH_NODE_TYPE_GRAPH"],[5,0,1,"","CU_GRAPH_NODE_TYPE_HOST"],[5,0,1,"","CU_GRAPH_NODE_TYPE_KERNEL"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEMCPY"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEMSET"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEM_ALLOC"],[5,0,1,"","CU_GRAPH_NODE_TYPE_MEM_FREE"],[5,0,1,"","CU_GRAPH_NODE_TYPE_WAIT_EVENT"]],"cuda.cuda.CUgraphicsMapResourceFlags":[[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE"],[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY"],[5,0,1,"","CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD"]],"cuda.cuda.CUgraphicsRegisterFlags":[[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_NONE"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER"],[5,0,1,"","CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD"]],"cuda.cuda.CUgraphicsResource":[[5,2,1,"","getPtr"]],"cuda.cuda.CUhostFn":[[5,2,1,"","getPtr"]],"cuda.cuda.CUipcEventHandle":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcEventHandle_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcEventHandle_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMemHandle_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUipcMem_flags":[[5,0,1,"","CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS"]],"cuda.cuda.CUjitInputType":[[5,0,1,"","CU_JIT_INPUT_CUBIN"],[5,0,1,"","CU_JIT_INPUT_FATBINARY"],[5,0,1,"","CU_JIT_INPUT_LIBRARY"],[5,0,1,"","CU_JIT_INPUT_NVVM"],[5,0,1,"","CU_JIT_INPUT_OBJECT"],[5,0,1,"","CU_JIT_INPUT_PTX"],[5,0,1,"","CU_JIT_NUM_INPUT_TYPES"]],"cuda.cuda.CUjit_cacheMode":[[5,0,1,"","CU_JIT_CACHE_OPTION_CA"],[5,0,1,"","CU_JIT_CACHE_OPTION_CG"],[5,0,1,"","CU_JIT_CACHE_OPTION_NONE"]],"cuda.cuda.CUjit_fallback":[[5,0,1,"","CU_PREFER_BINARY"],[5,0,1,"","CU_PREFER_PTX"]],"cuda.cuda.CUjit_option":[[5,0,1,"","CU_JIT_CACHE_MODE"],[5,0,1,"","CU_JIT_ERROR_LOG_BUFFER"],[5,0,1,"","CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES"],[5,0,1,"","CU_JIT_FALLBACK_STRATEGY"],[5,0,1,"","CU_JIT_FAST_COMPILE"],[5,0,1,"","CU_JIT_FMA"],[5,0,1,"","CU_JIT_FTZ"],[5,0,1,"","CU_JIT_GENERATE_DEBUG_INFO"],[5,0,1,"","CU_JIT_GENERATE_LINE_INFO"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_ADDRESSES"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_COUNT"],[5,0,1,"","CU_JIT_GLOBAL_SYMBOL_NAMES"],[5,0,1,"","CU_JIT_INFO_LOG_BUFFER"],[5,0,1,"","CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES"],[5,0,1,"","CU_JIT_LOG_VERBOSE"],[5,0,1,"","CU_JIT_LTO"],[5,0,1,"","CU_JIT_MAX_REGISTERS"],[5,0,1,"","CU_JIT_NEW_SM3X_OPT"],[5,0,1,"","CU_JIT_NUM_OPTIONS"],[5,0,1,"","CU_JIT_OPTIMIZATION_LEVEL"],[5,0,1,"","CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES"],[5,0,1,"","CU_JIT_PREC_DIV"],[5,0,1,"","CU_JIT_PREC_SQRT"],[5,0,1,"","CU_JIT_REFERENCED_KERNEL_COUNT"],[5,0,1,"","CU_JIT_REFERENCED_KERNEL_NAMES"],[5,0,1,"","CU_JIT_REFERENCED_VARIABLE_COUNT"],[5,0,1,"","CU_JIT_REFERENCED_VARIABLE_NAMES"],[5,0,1,"","CU_JIT_TARGET"],[5,0,1,"","CU_JIT_TARGET_FROM_CUCONTEXT"],[5,0,1,"","CU_JIT_THREADS_PER_BLOCK"],[5,0,1,"","CU_JIT_WALL_TIME"]],"cuda.cuda.CUjit_target":[[5,0,1,"","CU_TARGET_COMPUTE_20"],[5,0,1,"","CU_TARGET_COMPUTE_21"],[5,0,1,"","CU_TARGET_COMPUTE_30"],[5,0,1,"","CU_TARGET_COMPUTE_32"],[5,0,1,"","CU_TARGET_COMPUTE_35"],[5,0,1,"","CU_TARGET_COMPUTE_37"],[5,0,1,"","CU_TARGET_COMPUTE_50"],[5,0,1,"","CU_TARGET_COMPUTE_52"],[5,0,1,"","CU_TARGET_COMPUTE_53"],[5,0,1,"","CU_TARGET_COMPUTE_60"],[5,0,1,"","CU_TARGET_COMPUTE_61"],[5,0,1,"","CU_TARGET_COMPUTE_62"],[5,0,1,"","CU_TARGET_COMPUTE_70"],[5,0,1,"","CU_TARGET_COMPUTE_72"],[5,0,1,"","CU_TARGET_COMPUTE_75"],[5,0,1,"","CU_TARGET_COMPUTE_80"],[5,0,1,"","CU_TARGET_COMPUTE_86"],[5,0,1,"","CU_TARGET_COMPUTE_87"],[5,0,1,"","CU_TARGET_COMPUTE_89"],[5,0,1,"","CU_TARGET_COMPUTE_90"]],"cuda.cuda.CUkernelNodeAttrValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUkernelNodeAttrValue_v1":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttribute":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","value"]],"cuda.cuda.CUlaunchAttributeValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttributeValue_union":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUlaunchAttribute_st":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","value"]],"cuda.cuda.CUlaunchConfig":[[5,0,1,"","attrs"],[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","numAttrs"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUlaunchConfig_st":[[5,0,1,"","attrs"],[5,0,1,"","blockDimX"],[5,0,1,"","blockDimY"],[5,0,1,"","blockDimZ"],[5,2,1,"","getPtr"],[5,0,1,"","gridDimX"],[5,0,1,"","gridDimY"],[5,0,1,"","gridDimZ"],[5,0,1,"","hStream"],[5,0,1,"","numAttrs"],[5,0,1,"","sharedMemBytes"]],"cuda.cuda.CUlimit":[[5,0,1,"","CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT"],[5,0,1,"","CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH"],[5,0,1,"","CU_LIMIT_MALLOC_HEAP_SIZE"],[5,0,1,"","CU_LIMIT_MAX"],[5,0,1,"","CU_LIMIT_MAX_L2_FETCH_GRANULARITY"],[5,0,1,"","CU_LIMIT_PERSISTING_L2_CACHE_SIZE"],[5,0,1,"","CU_LIMIT_PRINTF_FIFO_SIZE"],[5,0,1,"","CU_LIMIT_STACK_SIZE"]],"cuda.cuda.CUlinkState":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemAccessDesc":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccessDesc_st":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccessDesc_v1":[[5,0,1,"","flags"],[5,2,1,"","getPtr"],[5,0,1,"","location"]],"cuda.cuda.CUmemAccess_flags":[[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_MAX"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_NONE"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_READ"],[5,0,1,"","CU_MEM_ACCESS_FLAGS_PROT_READWRITE"]],"cuda.cuda.CUmemAllocationCompType":[[5,0,1,"","CU_MEM_ALLOCATION_COMP_GENERIC"],[5,0,1,"","CU_MEM_ALLOCATION_COMP_NONE"]],"cuda.cuda.CUmemAllocationGranularity_flags":[[5,0,1,"","CU_MEM_ALLOC_GRANULARITY_MINIMUM"],[5,0,1,"","CU_MEM_ALLOC_GRANULARITY_RECOMMENDED"]],"cuda.cuda.CUmemAllocationHandleType":[[5,0,1,"","CU_MEM_HANDLE_TYPE_MAX"],[5,0,1,"","CU_MEM_HANDLE_TYPE_NONE"],[5,0,1,"","CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR"],[5,0,1,"","CU_MEM_HANDLE_TYPE_WIN32"],[5,0,1,"","CU_MEM_HANDLE_TYPE_WIN32_KMT"]],"cuda.cuda.CUmemAllocationProp":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationProp_st":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationProp_v1":[[5,0,1,"","allocFlags"],[5,2,1,"","getPtr"],[5,0,1,"","location"],[5,0,1,"","requestedHandleTypes"],[5,0,1,"","type"],[5,0,1,"","win32HandleMetaData"]],"cuda.cuda.CUmemAllocationType":[[5,0,1,"","CU_MEM_ALLOCATION_TYPE_INVALID"],[5,0,1,"","CU_MEM_ALLOCATION_TYPE_MAX"],[5,0,1,"","CU_MEM_ALLOCATION_TYPE_PINNED"]],"cuda.cuda.CUmemAttach_flags":[[5,0,1,"","CU_MEM_ATTACH_GLOBAL"],[5,0,1,"","CU_MEM_ATTACH_HOST"],[5,0,1,"","CU_MEM_ATTACH_SINGLE"]],"cuda.cuda.CUmemGenericAllocationHandle":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemGenericAllocationHandle_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemHandleType":[[5,0,1,"","CU_MEM_HANDLE_TYPE_GENERIC"]],"cuda.cuda.CUmemLocation":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemLocationType":[[5,0,1,"","CU_MEM_LOCATION_TYPE_DEVICE"],[5,0,1,"","CU_MEM_LOCATION_TYPE_INVALID"],[5,0,1,"","CU_MEM_LOCATION_TYPE_MAX"]],"cuda.cuda.CUmemLocation_st":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemLocation_v1":[[5,2,1,"","getPtr"],[5,0,1,"","id"],[5,0,1,"","type"]],"cuda.cuda.CUmemOperationType":[[5,0,1,"","CU_MEM_OPERATION_TYPE_MAP"],[5,0,1,"","CU_MEM_OPERATION_TYPE_UNMAP"]],"cuda.cuda.CUmemPoolProps":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolProps_st":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolProps_v1":[[5,0,1,"","allocType"],[5,2,1,"","getPtr"],[5,0,1,"","handleTypes"],[5,0,1,"","location"],[5,0,1,"","reserved"],[5,0,1,"","win32SecurityAttributes"]],"cuda.cuda.CUmemPoolPtrExportData":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPoolPtrExportData_st":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPoolPtrExportData_v1":[[5,2,1,"","getPtr"],[5,0,1,"","reserved"]],"cuda.cuda.CUmemPool_attribute":[[5,0,1,"","CU_MEMPOOL_ATTR_RELEASE_THRESHOLD"],[5,0,1,"","CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT"],[5,0,1,"","CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC"],[5,0,1,"","CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES"],[5,0,1,"","CU_MEMPOOL_ATTR_USED_MEM_CURRENT"],[5,0,1,"","CU_MEMPOOL_ATTR_USED_MEM_HIGH"]],"cuda.cuda.CUmemRangeHandleType":[[5,0,1,"","CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD"],[5,0,1,"","CU_MEM_RANGE_HANDLE_TYPE_MAX"]],"cuda.cuda.CUmem_advise":[[5,0,1,"","CU_MEM_ADVISE_SET_ACCESSED_BY"],[5,0,1,"","CU_MEM_ADVISE_SET_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_ADVISE_SET_READ_MOSTLY"],[5,0,1,"","CU_MEM_ADVISE_UNSET_ACCESSED_BY"],[5,0,1,"","CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_ADVISE_UNSET_READ_MOSTLY"]],"cuda.cuda.CUmem_range_attribute":[[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION"],[5,0,1,"","CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY"]],"cuda.cuda.CUmemoryPool":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmemorytype":[[5,0,1,"","CU_MEMORYTYPE_ARRAY"],[5,0,1,"","CU_MEMORYTYPE_DEVICE"],[5,0,1,"","CU_MEMORYTYPE_HOST"],[5,0,1,"","CU_MEMORYTYPE_UNIFIED"]],"cuda.cuda.CUmipmappedArray":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmodule":[[5,2,1,"","getPtr"]],"cuda.cuda.CUmoduleLoadingMode":[[5,0,1,"","CU_MODULE_EAGER_LOADING"],[5,0,1,"","CU_MODULE_LAZY_LOADING"]],"cuda.cuda.CUoccupancyB2DSize":[[5,2,1,"","getPtr"]],"cuda.cuda.CUoccupancy_flags":[[5,0,1,"","CU_OCCUPANCY_DEFAULT"],[5,0,1,"","CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE"]],"cuda.cuda.CUpointer_attribute":[[5,0,1,"","CU_POINTER_ATTRIBUTE_ACCESS_FLAGS"],[5,0,1,"","CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES"],[5,0,1,"","CU_POINTER_ATTRIBUTE_BUFFER_ID"],[5,0,1,"","CU_POINTER_ATTRIBUTE_CONTEXT"],[5,0,1,"","CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL"],[5,0,1,"","CU_POINTER_ATTRIBUTE_DEVICE_POINTER"],[5,0,1,"","CU_POINTER_ATTRIBUTE_HOST_POINTER"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_IS_MANAGED"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPED"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MAPPING_SIZE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMORY_TYPE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_P2P_TOKENS"],[5,0,1,"","CU_POINTER_ATTRIBUTE_RANGE_SIZE"],[5,0,1,"","CU_POINTER_ATTRIBUTE_RANGE_START_ADDR"],[5,0,1,"","CU_POINTER_ATTRIBUTE_SYNC_MEMOPS"]],"cuda.cuda.CUresourceViewFormat":[[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_FLOAT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_NONE"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC4"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC5"],[5,0,1,"","CU_RES_VIEW_FORMAT_SIGNED_BC6H"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_1X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_2X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_SINT_4X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_1X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_2X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X16"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X32"],[5,0,1,"","CU_RES_VIEW_FORMAT_UINT_4X8"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC1"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC2"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC3"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC4"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC5"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC6H"],[5,0,1,"","CU_RES_VIEW_FORMAT_UNSIGNED_BC7"]],"cuda.cuda.CUresourcetype":[[5,0,1,"","CU_RESOURCE_TYPE_ARRAY"],[5,0,1,"","CU_RESOURCE_TYPE_LINEAR"],[5,0,1,"","CU_RESOURCE_TYPE_MIPMAPPED_ARRAY"],[5,0,1,"","CU_RESOURCE_TYPE_PITCH2D"]],"cuda.cuda.CUresult":[[5,0,1,"","CUDA_ERROR_ALREADY_ACQUIRED"],[5,0,1,"","CUDA_ERROR_ALREADY_MAPPED"],[5,0,1,"","CUDA_ERROR_ARRAY_IS_MAPPED"],[5,0,1,"","CUDA_ERROR_ASSERT"],[5,0,1,"","CUDA_ERROR_CAPTURED_EVENT"],[5,0,1,"","CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE"],[5,0,1,"","CUDA_ERROR_CONTEXT_ALREADY_CURRENT"],[5,0,1,"","CUDA_ERROR_CONTEXT_ALREADY_IN_USE"],[5,0,1,"","CUDA_ERROR_CONTEXT_IS_DESTROYED"],[5,0,1,"","CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE"],[5,0,1,"","CUDA_ERROR_DEINITIALIZED"],[5,0,1,"","CUDA_ERROR_DEVICE_NOT_LICENSED"],[5,0,1,"","CUDA_ERROR_DEVICE_UNAVAILABLE"],[5,0,1,"","CUDA_ERROR_ECC_UNCORRECTABLE"],[5,0,1,"","CUDA_ERROR_EXTERNAL_DEVICE"],[5,0,1,"","CUDA_ERROR_FILE_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE"],[5,0,1,"","CUDA_ERROR_HARDWARE_STACK_ERROR"],[5,0,1,"","CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED"],[5,0,1,"","CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED"],[5,0,1,"","CUDA_ERROR_ILLEGAL_ADDRESS"],[5,0,1,"","CUDA_ERROR_ILLEGAL_INSTRUCTION"],[5,0,1,"","CUDA_ERROR_ILLEGAL_STATE"],[5,0,1,"","CUDA_ERROR_INVALID_ADDRESS_SPACE"],[5,0,1,"","CUDA_ERROR_INVALID_CLUSTER_SIZE"],[5,0,1,"","CUDA_ERROR_INVALID_CONTEXT"],[5,0,1,"","CUDA_ERROR_INVALID_DEVICE"],[5,0,1,"","CUDA_ERROR_INVALID_GRAPHICS_CONTEXT"],[5,0,1,"","CUDA_ERROR_INVALID_HANDLE"],[5,0,1,"","CUDA_ERROR_INVALID_IMAGE"],[5,0,1,"","CUDA_ERROR_INVALID_PC"],[5,0,1,"","CUDA_ERROR_INVALID_PTX"],[5,0,1,"","CUDA_ERROR_INVALID_SOURCE"],[5,0,1,"","CUDA_ERROR_INVALID_VALUE"],[5,0,1,"","CUDA_ERROR_JIT_COMPILATION_DISABLED"],[5,0,1,"","CUDA_ERROR_JIT_COMPILER_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_LAUNCH_FAILED"],[5,0,1,"","CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING"],[5,0,1,"","CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES"],[5,0,1,"","CUDA_ERROR_LAUNCH_TIMEOUT"],[5,0,1,"","CUDA_ERROR_MAP_FAILED"],[5,0,1,"","CUDA_ERROR_MISALIGNED_ADDRESS"],[5,0,1,"","CUDA_ERROR_MPS_CLIENT_TERMINATED"],[5,0,1,"","CUDA_ERROR_MPS_CONNECTION_FAILED"],[5,0,1,"","CUDA_ERROR_MPS_MAX_CLIENTS_REACHED"],[5,0,1,"","CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED"],[5,0,1,"","CUDA_ERROR_MPS_RPC_FAILURE"],[5,0,1,"","CUDA_ERROR_MPS_SERVER_NOT_READY"],[5,0,1,"","CUDA_ERROR_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_NOT_INITIALIZED"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED_AS_ARRAY"],[5,0,1,"","CUDA_ERROR_NOT_MAPPED_AS_POINTER"],[5,0,1,"","CUDA_ERROR_NOT_PERMITTED"],[5,0,1,"","CUDA_ERROR_NOT_READY"],[5,0,1,"","CUDA_ERROR_NOT_SUPPORTED"],[5,0,1,"","CUDA_ERROR_NO_BINARY_FOR_GPU"],[5,0,1,"","CUDA_ERROR_NO_DEVICE"],[5,0,1,"","CUDA_ERROR_NVLINK_UNCORRECTABLE"],[5,0,1,"","CUDA_ERROR_OPERATING_SYSTEM"],[5,0,1,"","CUDA_ERROR_OUT_OF_MEMORY"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_NOT_ENABLED"],[5,0,1,"","CUDA_ERROR_PEER_ACCESS_UNSUPPORTED"],[5,0,1,"","CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE"],[5,0,1,"","CUDA_ERROR_PROFILER_ALREADY_STARTED"],[5,0,1,"","CUDA_ERROR_PROFILER_ALREADY_STOPPED"],[5,0,1,"","CUDA_ERROR_PROFILER_DISABLED"],[5,0,1,"","CUDA_ERROR_PROFILER_NOT_INITIALIZED"],[5,0,1,"","CUDA_ERROR_SHARED_OBJECT_INIT_FAILED"],[5,0,1,"","CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_IMPLICIT"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_INVALIDATED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_ISOLATION"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_MERGE"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNJOINED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNMATCHED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED"],[5,0,1,"","CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD"],[5,0,1,"","CUDA_ERROR_STUB_LIBRARY"],[5,0,1,"","CUDA_ERROR_SYSTEM_DRIVER_MISMATCH"],[5,0,1,"","CUDA_ERROR_SYSTEM_NOT_READY"],[5,0,1,"","CUDA_ERROR_TIMEOUT"],[5,0,1,"","CUDA_ERROR_TOO_MANY_PEERS"],[5,0,1,"","CUDA_ERROR_UNKNOWN"],[5,0,1,"","CUDA_ERROR_UNMAP_FAILED"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_LIMIT"],[5,0,1,"","CUDA_ERROR_UNSUPPORTED_PTX_VERSION"],[5,0,1,"","CUDA_SUCCESS"]],"cuda.cuda.CUshared_carveout":[[5,0,1,"","CU_SHAREDMEM_CARVEOUT_DEFAULT"],[5,0,1,"","CU_SHAREDMEM_CARVEOUT_MAX_L1"],[5,0,1,"","CU_SHAREDMEM_CARVEOUT_MAX_SHARED"]],"cuda.cuda.CUsharedconfig":[[5,0,1,"","CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE"],[5,0,1,"","CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE"],[5,0,1,"","CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE"]],"cuda.cuda.CUstream":[[5,2,1,"","getPtr"]],"cuda.cuda.CUstreamAttrID":[[5,0,1,"","CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_COOPERATIVE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_IGNORE"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PRIORITY"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION"],[5,0,1,"","CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY"]],"cuda.cuda.CUstreamAttrValue":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUstreamAttrValue_v1":[[5,0,1,"","accessPolicyWindow"],[5,0,1,"","clusterDim"],[5,0,1,"","clusterSchedulingPolicyPreference"],[5,0,1,"","cooperative"],[5,2,1,"","getPtr"],[5,0,1,"","pad"],[5,0,1,"","priority"],[5,0,1,"","programmaticEvent"],[5,0,1,"","programmaticStreamSerializationAllowed"],[5,0,1,"","syncPolicy"]],"cuda.cuda.CUstreamBatchMemOpParams":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpParams_union":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpParams_v1":[[5,0,1,"","flushRemoteWrites"],[5,2,1,"","getPtr"],[5,0,1,"","memoryBarrier"],[5,0,1,"","operation"],[5,0,1,"","pad"],[5,0,1,"","waitValue"],[5,0,1,"","writeValue"]],"cuda.cuda.CUstreamBatchMemOpType":[[5,0,1,"","CU_STREAM_MEM_OP_BARRIER"],[5,0,1,"","CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES"],[5,0,1,"","CU_STREAM_MEM_OP_WAIT_VALUE_32"],[5,0,1,"","CU_STREAM_MEM_OP_WAIT_VALUE_64"],[5,0,1,"","CU_STREAM_MEM_OP_WRITE_VALUE_32"],[5,0,1,"","CU_STREAM_MEM_OP_WRITE_VALUE_64"]],"cuda.cuda.CUstreamCallback":[[5,2,1,"","getPtr"]],"cuda.cuda.CUstreamCaptureMode":[[5,0,1,"","CU_STREAM_CAPTURE_MODE_GLOBAL"],[5,0,1,"","CU_STREAM_CAPTURE_MODE_RELAXED"],[5,0,1,"","CU_STREAM_CAPTURE_MODE_THREAD_LOCAL"]],"cuda.cuda.CUstreamCaptureStatus":[[5,0,1,"","CU_STREAM_CAPTURE_STATUS_ACTIVE"],[5,0,1,"","CU_STREAM_CAPTURE_STATUS_INVALIDATED"],[5,0,1,"","CU_STREAM_CAPTURE_STATUS_NONE"]],"cuda.cuda.CUstreamMemoryBarrier_flags":[[5,0,1,"","CU_STREAM_MEMORY_BARRIER_TYPE_GPU"],[5,0,1,"","CU_STREAM_MEMORY_BARRIER_TYPE_SYS"]],"cuda.cuda.CUstreamUpdateCaptureDependencies_flags":[[5,0,1,"","CU_STREAM_ADD_CAPTURE_DEPENDENCIES"],[5,0,1,"","CU_STREAM_SET_CAPTURE_DEPENDENCIES"]],"cuda.cuda.CUstreamWaitValue_flags":[[5,0,1,"","CU_STREAM_WAIT_VALUE_AND"],[5,0,1,"","CU_STREAM_WAIT_VALUE_EQ"],[5,0,1,"","CU_STREAM_WAIT_VALUE_FLUSH"],[5,0,1,"","CU_STREAM_WAIT_VALUE_GEQ"],[5,0,1,"","CU_STREAM_WAIT_VALUE_NOR"]],"cuda.cuda.CUstreamWriteValue_flags":[[5,0,1,"","CU_STREAM_WRITE_VALUE_DEFAULT"],[5,0,1,"","CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER"]],"cuda.cuda.CUstream_flags":[[5,0,1,"","CU_STREAM_DEFAULT"],[5,0,1,"","CU_STREAM_NON_BLOCKING"]],"cuda.cuda.CUsurfObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsurfObject_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsurfref":[[5,2,1,"","getPtr"]],"cuda.cuda.CUsynchronizationPolicy":[[5,0,1,"","CU_SYNC_POLICY_AUTO"],[5,0,1,"","CU_SYNC_POLICY_BLOCKING_SYNC"],[5,0,1,"","CU_SYNC_POLICY_SPIN"],[5,0,1,"","CU_SYNC_POLICY_YIELD"]],"cuda.cuda.CUtexObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUtexObject_v1":[[5,2,1,"","getPtr"]],"cuda.cuda.CUtexref":[[5,2,1,"","getPtr"]],"cuda.cuda.CUuserObject":[[5,2,1,"","getPtr"]],"cuda.cuda.CUuserObjectRetain_flags":[[5,0,1,"","CU_GRAPH_USER_OBJECT_MOVE"]],"cuda.cuda.CUuserObject_flags":[[5,0,1,"","CU_USER_OBJECT_NO_DESTRUCTOR_SYNC"]],"cuda.cuda.CUuuid":[[5,0,1,"","bytes"],[5,2,1,"","getPtr"]],"cuda.cuda.CUuuid_st":[[5,0,1,"","bytes"],[5,2,1,"","getPtr"]],"cuda.cuda.cl_context_flags":[[5,0,1,"","NVCL_CTX_SCHED_AUTO"],[5,0,1,"","NVCL_CTX_SCHED_BLOCKING_SYNC"],[5,0,1,"","NVCL_CTX_SCHED_SPIN"],[5,0,1,"","NVCL_CTX_SCHED_YIELD"]],"cuda.cuda.cl_event_flags":[[5,0,1,"","NVCL_EVENT_SCHED_AUTO"],[5,0,1,"","NVCL_EVENT_SCHED_BLOCKING_SYNC"],[5,0,1,"","NVCL_EVENT_SCHED_SPIN"],[5,0,1,"","NVCL_EVENT_SCHED_YIELD"]],"cuda.cudart":[[6,0,1,"","CUDA_EGL_MAX_PLANES"],[6,0,1,"","CUDA_IPC_HANDLE_SIZE"],[6,1,1,"","CUuuid"],[6,1,1,"","CUuuid_st"],[6,1,1,"","cudaAccessPolicyWindow"],[6,1,1,"","cudaAccessProperty"],[6,0,1,"","cudaArrayColorAttachment"],[6,0,1,"","cudaArrayCubemap"],[6,0,1,"","cudaArrayDefault"],[6,0,1,"","cudaArrayDeferredMapping"],[6,3,1,"","cudaArrayGetInfo"],[6,3,1,"","cudaArrayGetMemoryRequirements"],[6,3,1,"","cudaArrayGetPlane"],[6,3,1,"","cudaArrayGetSparseProperties"],[6,0,1,"","cudaArrayLayered"],[6,1,1,"","cudaArrayMemoryRequirements"],[6,0,1,"","cudaArraySparse"],[6,1,1,"","cudaArraySparseProperties"],[6,0,1,"","cudaArraySparsePropertiesSingleMipTail"],[6,0,1,"","cudaArraySurfaceLoadStore"],[6,0,1,"","cudaArrayTextureGather"],[6,1,1,"","cudaArray_const_t"],[6,1,1,"","cudaArray_t"],[6,1,1,"","cudaCGScope"],[6,1,1,"","cudaChannelFormatDesc"],[6,1,1,"","cudaChannelFormatKind"],[6,3,1,"","cudaChooseDevice"],[6,1,1,"","cudaClusterSchedulingPolicy"],[6,1,1,"","cudaComputeMode"],[6,0,1,"","cudaCooperativeLaunchMultiDeviceNoPostSync"],[6,0,1,"","cudaCooperativeLaunchMultiDeviceNoPreSync"],[6,0,1,"","cudaCpuDeviceId"],[6,3,1,"","cudaCreateChannelDesc"],[6,3,1,"","cudaCreateSurfaceObject"],[6,3,1,"","cudaCreateTextureObject"],[6,3,1,"","cudaCreateTextureObject_v2"],[6,3,1,"","cudaCtxResetPersistingL2Cache"],[6,3,1,"","cudaDestroyExternalMemory"],[6,3,1,"","cudaDestroyExternalSemaphore"],[6,3,1,"","cudaDestroySurfaceObject"],[6,3,1,"","cudaDestroyTextureObject"],[6,1,1,"","cudaDeviceAttr"],[6,0,1,"","cudaDeviceBlockingSync"],[6,3,1,"","cudaDeviceCanAccessPeer"],[6,3,1,"","cudaDeviceDisablePeerAccess"],[6,3,1,"","cudaDeviceEnablePeerAccess"],[6,3,1,"","cudaDeviceFlushGPUDirectRDMAWrites"],[6,3,1,"","cudaDeviceGetAttribute"],[6,3,1,"","cudaDeviceGetByPCIBusId"],[6,3,1,"","cudaDeviceGetCacheConfig"],[6,3,1,"","cudaDeviceGetDefaultMemPool"],[6,3,1,"","cudaDeviceGetGraphMemAttribute"],[6,3,1,"","cudaDeviceGetLimit"],[6,3,1,"","cudaDeviceGetMemPool"],[6,3,1,"","cudaDeviceGetNvSciSyncAttributes"],[6,3,1,"","cudaDeviceGetP2PAttribute"],[6,3,1,"","cudaDeviceGetPCIBusId"],[6,3,1,"","cudaDeviceGetSharedMemConfig"],[6,3,1,"","cudaDeviceGetStreamPriorityRange"],[6,3,1,"","cudaDeviceGetTexture1DLinearMaxWidth"],[6,3,1,"","cudaDeviceGraphMemTrim"],[6,0,1,"","cudaDeviceLmemResizeToMax"],[6,0,1,"","cudaDeviceMapHost"],[6,0,1,"","cudaDeviceMask"],[6,1,1,"","cudaDeviceP2PAttr"],[6,1,1,"","cudaDeviceProp"],[6,3,1,"","cudaDeviceReset"],[6,0,1,"","cudaDeviceScheduleAuto"],[6,0,1,"","cudaDeviceScheduleBlockingSync"],[6,0,1,"","cudaDeviceScheduleMask"],[6,0,1,"","cudaDeviceScheduleSpin"],[6,0,1,"","cudaDeviceScheduleYield"],[6,3,1,"","cudaDeviceSetCacheConfig"],[6,3,1,"","cudaDeviceSetGraphMemAttribute"],[6,3,1,"","cudaDeviceSetLimit"],[6,3,1,"","cudaDeviceSetMemPool"],[6,3,1,"","cudaDeviceSetSharedMemConfig"],[6,3,1,"","cudaDeviceSynchronize"],[6,3,1,"","cudaDriverGetVersion"],[6,3,1,"","cudaEGLStreamConsumerAcquireFrame"],[6,3,1,"","cudaEGLStreamConsumerConnect"],[6,3,1,"","cudaEGLStreamConsumerConnectWithFlags"],[6,3,1,"","cudaEGLStreamConsumerDisconnect"],[6,3,1,"","cudaEGLStreamConsumerReleaseFrame"],[6,3,1,"","cudaEGLStreamProducerConnect"],[6,3,1,"","cudaEGLStreamProducerDisconnect"],[6,3,1,"","cudaEGLStreamProducerPresentFrame"],[6,3,1,"","cudaEGLStreamProducerReturnFrame"],[6,1,1,"","cudaEglColorFormat"],[6,1,1,"","cudaEglFrame"],[6,1,1,"","cudaEglFrameType"],[6,1,1,"","cudaEglFrame_st"],[6,1,1,"","cudaEglPlaneDesc"],[6,1,1,"","cudaEglPlaneDesc_st"],[6,1,1,"","cudaEglResourceLocationFlags"],[6,1,1,"","cudaEglStreamConnection"],[6,1,1,"","cudaError_t"],[6,0,1,"","cudaEventBlockingSync"],[6,3,1,"","cudaEventCreate"],[6,3,1,"","cudaEventCreateFromEGLSync"],[6,3,1,"","cudaEventCreateWithFlags"],[6,0,1,"","cudaEventDefault"],[6,3,1,"","cudaEventDestroy"],[6,0,1,"","cudaEventDisableTiming"],[6,3,1,"","cudaEventElapsedTime"],[6,0,1,"","cudaEventInterprocess"],[6,3,1,"","cudaEventQuery"],[6,3,1,"","cudaEventRecord"],[6,0,1,"","cudaEventRecordDefault"],[6,0,1,"","cudaEventRecordExternal"],[6,3,1,"","cudaEventRecordWithFlags"],[6,3,1,"","cudaEventSynchronize"],[6,0,1,"","cudaEventWaitDefault"],[6,0,1,"","cudaEventWaitExternal"],[6,1,1,"","cudaEvent_t"],[6,1,1,"","cudaExtent"],[6,1,1,"","cudaExternalMemoryBufferDesc"],[6,0,1,"","cudaExternalMemoryDedicated"],[6,3,1,"","cudaExternalMemoryGetMappedBuffer"],[6,3,1,"","cudaExternalMemoryGetMappedMipmappedArray"],[6,1,1,"","cudaExternalMemoryHandleDesc"],[6,1,1,"","cudaExternalMemoryHandleType"],[6,1,1,"","cudaExternalMemoryMipmappedArrayDesc"],[6,1,1,"","cudaExternalMemory_t"],[6,1,1,"","cudaExternalSemaphoreHandleDesc"],[6,1,1,"","cudaExternalSemaphoreHandleType"],[6,1,1,"","cudaExternalSemaphoreSignalNodeParams"],[6,1,1,"","cudaExternalSemaphoreSignalParams"],[6,0,1,"","cudaExternalSemaphoreSignalSkipNvSciBufMemSync"],[6,1,1,"","cudaExternalSemaphoreWaitNodeParams"],[6,1,1,"","cudaExternalSemaphoreWaitParams"],[6,0,1,"","cudaExternalSemaphoreWaitSkipNvSciBufMemSync"],[6,1,1,"","cudaExternalSemaphore_t"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesOptions"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesScope"],[6,1,1,"","cudaFlushGPUDirectRDMAWritesTarget"],[6,3,1,"","cudaFree"],[6,3,1,"","cudaFreeArray"],[6,3,1,"","cudaFreeAsync"],[6,3,1,"","cudaFreeHost"],[6,3,1,"","cudaFreeMipmappedArray"],[6,1,1,"","cudaFuncAttribute"],[6,1,1,"","cudaFuncAttributes"],[6,1,1,"","cudaFuncCache"],[6,3,1,"","cudaFuncGetAttributes"],[6,3,1,"","cudaFuncSetAttribute"],[6,3,1,"","cudaFuncSetCacheConfig"],[6,3,1,"","cudaFuncSetSharedMemConfig"],[6,1,1,"","cudaFunction_t"],[6,1,1,"","cudaGLDeviceList"],[6,3,1,"","cudaGLGetDevices"],[6,1,1,"","cudaGPUDirectRDMAWritesOrdering"],[6,3,1,"","cudaGetChannelDesc"],[6,3,1,"","cudaGetDevice"],[6,3,1,"","cudaGetDeviceCount"],[6,3,1,"","cudaGetDeviceFlags"],[6,3,1,"","cudaGetDeviceProperties"],[6,3,1,"","cudaGetDriverEntryPoint"],[6,1,1,"","cudaGetDriverEntryPointFlags"],[6,3,1,"","cudaGetErrorName"],[6,3,1,"","cudaGetErrorString"],[6,3,1,"","cudaGetLastError"],[6,3,1,"","cudaGetMipmappedArrayLevel"],[6,3,1,"","cudaGetSurfaceObjectResourceDesc"],[6,3,1,"","cudaGetTextureObjectResourceDesc"],[6,3,1,"","cudaGetTextureObjectResourceViewDesc"],[6,3,1,"","cudaGetTextureObjectTextureDesc"],[6,3,1,"","cudaGetTextureObjectTextureDesc_v2"],[6,3,1,"","cudaGraphAddChildGraphNode"],[6,3,1,"","cudaGraphAddDependencies"],[6,3,1,"","cudaGraphAddEmptyNode"],[6,3,1,"","cudaGraphAddEventRecordNode"],[6,3,1,"","cudaGraphAddEventWaitNode"],[6,3,1,"","cudaGraphAddExternalSemaphoresSignalNode"],[6,3,1,"","cudaGraphAddExternalSemaphoresWaitNode"],[6,3,1,"","cudaGraphAddHostNode"],[6,3,1,"","cudaGraphAddKernelNode"],[6,3,1,"","cudaGraphAddMemAllocNode"],[6,3,1,"","cudaGraphAddMemFreeNode"],[6,3,1,"","cudaGraphAddMemcpyNode"],[6,3,1,"","cudaGraphAddMemcpyNode1D"],[6,3,1,"","cudaGraphAddMemsetNode"],[6,3,1,"","cudaGraphChildGraphNodeGetGraph"],[6,3,1,"","cudaGraphClone"],[6,3,1,"","cudaGraphCreate"],[6,1,1,"","cudaGraphDebugDotFlags"],[6,3,1,"","cudaGraphDebugDotPrint"],[6,3,1,"","cudaGraphDestroy"],[6,3,1,"","cudaGraphDestroyNode"],[6,3,1,"","cudaGraphEventRecordNodeGetEvent"],[6,3,1,"","cudaGraphEventRecordNodeSetEvent"],[6,3,1,"","cudaGraphEventWaitNodeGetEvent"],[6,3,1,"","cudaGraphEventWaitNodeSetEvent"],[6,3,1,"","cudaGraphExecChildGraphNodeSetParams"],[6,3,1,"","cudaGraphExecDestroy"],[6,3,1,"","cudaGraphExecEventRecordNodeSetEvent"],[6,3,1,"","cudaGraphExecEventWaitNodeSetEvent"],[6,3,1,"","cudaGraphExecExternalSemaphoresSignalNodeSetParams"],[6,3,1,"","cudaGraphExecExternalSemaphoresWaitNodeSetParams"],[6,3,1,"","cudaGraphExecHostNodeSetParams"],[6,3,1,"","cudaGraphExecKernelNodeSetParams"],[6,3,1,"","cudaGraphExecMemcpyNodeSetParams"],[6,3,1,"","cudaGraphExecMemcpyNodeSetParams1D"],[6,3,1,"","cudaGraphExecMemsetNodeSetParams"],[6,3,1,"","cudaGraphExecUpdate"],[6,1,1,"","cudaGraphExecUpdateResult"],[6,1,1,"","cudaGraphExec_t"],[6,3,1,"","cudaGraphExternalSemaphoresSignalNodeGetParams"],[6,3,1,"","cudaGraphExternalSemaphoresSignalNodeSetParams"],[6,3,1,"","cudaGraphExternalSemaphoresWaitNodeGetParams"],[6,3,1,"","cudaGraphExternalSemaphoresWaitNodeSetParams"],[6,3,1,"","cudaGraphGetEdges"],[6,3,1,"","cudaGraphGetNodes"],[6,3,1,"","cudaGraphGetRootNodes"],[6,3,1,"","cudaGraphHostNodeGetParams"],[6,3,1,"","cudaGraphHostNodeSetParams"],[6,3,1,"","cudaGraphInstantiate"],[6,1,1,"","cudaGraphInstantiateFlags"],[6,3,1,"","cudaGraphInstantiateWithFlags"],[6,3,1,"","cudaGraphKernelNodeCopyAttributes"],[6,3,1,"","cudaGraphKernelNodeGetAttribute"],[6,3,1,"","cudaGraphKernelNodeGetParams"],[6,3,1,"","cudaGraphKernelNodeSetAttribute"],[6,3,1,"","cudaGraphKernelNodeSetParams"],[6,3,1,"","cudaGraphLaunch"],[6,3,1,"","cudaGraphMemAllocNodeGetParams"],[6,1,1,"","cudaGraphMemAttributeType"],[6,3,1,"","cudaGraphMemFreeNodeGetParams"],[6,3,1,"","cudaGraphMemcpyNodeGetParams"],[6,3,1,"","cudaGraphMemcpyNodeSetParams"],[6,3,1,"","cudaGraphMemcpyNodeSetParams1D"],[6,3,1,"","cudaGraphMemsetNodeGetParams"],[6,3,1,"","cudaGraphMemsetNodeSetParams"],[6,3,1,"","cudaGraphNodeFindInClone"],[6,3,1,"","cudaGraphNodeGetDependencies"],[6,3,1,"","cudaGraphNodeGetDependentNodes"],[6,3,1,"","cudaGraphNodeGetEnabled"],[6,3,1,"","cudaGraphNodeGetType"],[6,3,1,"","cudaGraphNodeSetEnabled"],[6,1,1,"","cudaGraphNodeType"],[6,1,1,"","cudaGraphNode_t"],[6,3,1,"","cudaGraphReleaseUserObject"],[6,3,1,"","cudaGraphRemoveDependencies"],[6,3,1,"","cudaGraphRetainUserObject"],[6,3,1,"","cudaGraphUpload"],[6,1,1,"","cudaGraph_t"],[6,1,1,"","cudaGraphicsCubeFace"],[6,3,1,"","cudaGraphicsEGLRegisterImage"],[6,3,1,"","cudaGraphicsGLRegisterBuffer"],[6,3,1,"","cudaGraphicsGLRegisterImage"],[6,1,1,"","cudaGraphicsMapFlags"],[6,3,1,"","cudaGraphicsMapResources"],[6,1,1,"","cudaGraphicsRegisterFlags"],[6,3,1,"","cudaGraphicsResourceGetMappedEglFrame"],[6,3,1,"","cudaGraphicsResourceGetMappedMipmappedArray"],[6,3,1,"","cudaGraphicsResourceGetMappedPointer"],[6,3,1,"","cudaGraphicsResourceSetMapFlags"],[6,1,1,"","cudaGraphicsResource_t"],[6,3,1,"","cudaGraphicsSubResourceGetMappedArray"],[6,3,1,"","cudaGraphicsUnmapResources"],[6,3,1,"","cudaGraphicsUnregisterResource"],[6,3,1,"","cudaGraphicsVDPAURegisterOutputSurface"],[6,3,1,"","cudaGraphicsVDPAURegisterVideoSurface"],[6,3,1,"","cudaHostAlloc"],[6,0,1,"","cudaHostAllocDefault"],[6,0,1,"","cudaHostAllocMapped"],[6,0,1,"","cudaHostAllocPortable"],[6,0,1,"","cudaHostAllocWriteCombined"],[6,1,1,"","cudaHostFn_t"],[6,3,1,"","cudaHostGetDevicePointer"],[6,3,1,"","cudaHostGetFlags"],[6,1,1,"","cudaHostNodeParams"],[6,3,1,"","cudaHostRegister"],[6,0,1,"","cudaHostRegisterDefault"],[6,0,1,"","cudaHostRegisterIoMemory"],[6,0,1,"","cudaHostRegisterMapped"],[6,0,1,"","cudaHostRegisterPortable"],[6,0,1,"","cudaHostRegisterReadOnly"],[6,3,1,"","cudaHostUnregister"],[6,3,1,"","cudaImportExternalMemory"],[6,3,1,"","cudaImportExternalSemaphore"],[6,0,1,"","cudaInvalidDeviceId"],[6,3,1,"","cudaIpcCloseMemHandle"],[6,1,1,"","cudaIpcEventHandle_st"],[6,1,1,"","cudaIpcEventHandle_t"],[6,3,1,"","cudaIpcGetEventHandle"],[6,3,1,"","cudaIpcGetMemHandle"],[6,1,1,"","cudaIpcMemHandle_st"],[6,1,1,"","cudaIpcMemHandle_t"],[6,0,1,"","cudaIpcMemLazyEnablePeerAccess"],[6,3,1,"","cudaIpcOpenEventHandle"],[6,3,1,"","cudaIpcOpenMemHandle"],[6,0,1,"","cudaKernelNodeAttrID"],[6,0,1,"","cudaKernelNodeAttrValue"],[6,0,1,"","cudaKernelNodeAttributeClusterDimension"],[6,0,1,"","cudaKernelNodeAttributeClusterSchedulingPolicyPreference"],[6,1,1,"","cudaKernelNodeParams"],[6,1,1,"","cudaLaunchAttribute"],[6,1,1,"","cudaLaunchAttributeID"],[6,1,1,"id0","cudaLaunchAttributeValue"],[6,1,1,"","cudaLaunchAttribute_st"],[6,3,1,"","cudaLaunchHostFunc"],[6,1,1,"","cudaLimit"],[6,3,1,"","cudaMalloc"],[6,3,1,"","cudaMalloc3D"],[6,3,1,"","cudaMalloc3DArray"],[6,3,1,"","cudaMallocArray"],[6,3,1,"","cudaMallocAsync"],[6,3,1,"","cudaMallocFromPoolAsync"],[6,3,1,"","cudaMallocHost"],[6,3,1,"","cudaMallocManaged"],[6,3,1,"","cudaMallocMipmappedArray"],[6,3,1,"","cudaMallocPitch"],[6,1,1,"","cudaMemAccessDesc"],[6,1,1,"","cudaMemAccessFlags"],[6,3,1,"","cudaMemAdvise"],[6,1,1,"","cudaMemAllocNodeParams"],[6,1,1,"","cudaMemAllocationHandleType"],[6,1,1,"","cudaMemAllocationType"],[6,0,1,"","cudaMemAttachGlobal"],[6,0,1,"","cudaMemAttachHost"],[6,0,1,"","cudaMemAttachSingle"],[6,3,1,"","cudaMemGetInfo"],[6,1,1,"","cudaMemLocation"],[6,1,1,"","cudaMemLocationType"],[6,1,1,"","cudaMemPoolAttr"],[6,3,1,"","cudaMemPoolCreate"],[6,3,1,"","cudaMemPoolDestroy"],[6,3,1,"","cudaMemPoolExportPointer"],[6,3,1,"","cudaMemPoolExportToShareableHandle"],[6,3,1,"","cudaMemPoolGetAccess"],[6,3,1,"","cudaMemPoolGetAttribute"],[6,3,1,"","cudaMemPoolImportFromShareableHandle"],[6,3,1,"","cudaMemPoolImportPointer"],[6,1,1,"","cudaMemPoolProps"],[6,1,1,"","cudaMemPoolPtrExportData"],[6,3,1,"","cudaMemPoolSetAccess"],[6,3,1,"","cudaMemPoolSetAttribute"],[6,3,1,"","cudaMemPoolTrimTo"],[6,1,1,"","cudaMemPool_t"],[6,3,1,"","cudaMemPrefetchAsync"],[6,1,1,"","cudaMemRangeAttribute"],[6,3,1,"","cudaMemRangeGetAttribute"],[6,3,1,"","cudaMemRangeGetAttributes"],[6,3,1,"","cudaMemcpy"],[6,3,1,"","cudaMemcpy2D"],[6,3,1,"","cudaMemcpy2DArrayToArray"],[6,3,1,"","cudaMemcpy2DAsync"],[6,3,1,"","cudaMemcpy2DFromArray"],[6,3,1,"","cudaMemcpy2DFromArrayAsync"],[6,3,1,"","cudaMemcpy2DToArray"],[6,3,1,"","cudaMemcpy2DToArrayAsync"],[6,3,1,"","cudaMemcpy3D"],[6,3,1,"","cudaMemcpy3DAsync"],[6,1,1,"","cudaMemcpy3DParms"],[6,3,1,"","cudaMemcpy3DPeer"],[6,3,1,"","cudaMemcpy3DPeerAsync"],[6,1,1,"","cudaMemcpy3DPeerParms"],[6,3,1,"","cudaMemcpyAsync"],[6,1,1,"","cudaMemcpyKind"],[6,3,1,"","cudaMemcpyPeer"],[6,3,1,"","cudaMemcpyPeerAsync"],[6,1,1,"","cudaMemoryAdvise"],[6,1,1,"","cudaMemoryType"],[6,3,1,"","cudaMemset"],[6,3,1,"","cudaMemset2D"],[6,3,1,"","cudaMemset2DAsync"],[6,3,1,"","cudaMemset3D"],[6,3,1,"","cudaMemset3DAsync"],[6,3,1,"","cudaMemsetAsync"],[6,1,1,"","cudaMemsetParams"],[6,3,1,"","cudaMipmappedArrayGetMemoryRequirements"],[6,3,1,"","cudaMipmappedArrayGetSparseProperties"],[6,1,1,"","cudaMipmappedArray_const_t"],[6,1,1,"","cudaMipmappedArray_t"],[6,0,1,"","cudaNvSciSyncAttrSignal"],[6,0,1,"","cudaNvSciSyncAttrWait"],[6,3,1,"","cudaOccupancyAvailableDynamicSMemPerBlock"],[6,0,1,"","cudaOccupancyDefault"],[6,0,1,"","cudaOccupancyDisableCachingOverride"],[6,3,1,"","cudaOccupancyMaxActiveBlocksPerMultiprocessor"],[6,3,1,"","cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags"],[6,1,1,"","cudaOutputMode_t"],[6,3,1,"","cudaPeekAtLastError"],[6,0,1,"","cudaPeerAccessDefault"],[6,1,1,"","cudaPitchedPtr"],[6,1,1,"","cudaPointerAttributes"],[6,3,1,"","cudaPointerGetAttributes"],[6,1,1,"","cudaPos"],[6,3,1,"","cudaProfilerStart"],[6,3,1,"","cudaProfilerStop"],[6,1,1,"","cudaResourceDesc"],[6,1,1,"","cudaResourceType"],[6,1,1,"","cudaResourceViewDesc"],[6,1,1,"","cudaResourceViewFormat"],[6,3,1,"","cudaRuntimeGetVersion"],[6,3,1,"","cudaSetDevice"],[6,3,1,"","cudaSetDeviceFlags"],[6,3,1,"","cudaSetDoubleForDevice"],[6,3,1,"","cudaSetDoubleForHost"],[6,1,1,"","cudaSharedCarveout"],[6,1,1,"","cudaSharedMemConfig"],[6,3,1,"","cudaSignalExternalSemaphoresAsync"],[6,3,1,"","cudaStreamAddCallback"],[6,3,1,"","cudaStreamAttachMemAsync"],[6,0,1,"","cudaStreamAttrID"],[6,0,1,"","cudaStreamAttrValue"],[6,3,1,"","cudaStreamBeginCapture"],[6,1,1,"","cudaStreamCallback_t"],[6,1,1,"","cudaStreamCaptureMode"],[6,1,1,"","cudaStreamCaptureStatus"],[6,3,1,"","cudaStreamCopyAttributes"],[6,3,1,"","cudaStreamCreate"],[6,3,1,"","cudaStreamCreateWithFlags"],[6,3,1,"","cudaStreamCreateWithPriority"],[6,0,1,"","cudaStreamDefault"],[6,3,1,"","cudaStreamDestroy"],[6,3,1,"","cudaStreamEndCapture"],[6,3,1,"","cudaStreamGetAttribute"],[6,3,1,"","cudaStreamGetCaptureInfo"],[6,3,1,"","cudaStreamGetCaptureInfo_v2"],[6,3,1,"","cudaStreamGetFlags"],[6,3,1,"","cudaStreamGetPriority"],[6,3,1,"","cudaStreamIsCapturing"],[6,0,1,"","cudaStreamLegacy"],[6,0,1,"","cudaStreamNonBlocking"],[6,0,1,"","cudaStreamPerThread"],[6,3,1,"","cudaStreamQuery"],[6,3,1,"","cudaStreamSetAttribute"],[6,3,1,"","cudaStreamSynchronize"],[6,3,1,"","cudaStreamUpdateCaptureDependencies"],[6,1,1,"","cudaStreamUpdateCaptureDependenciesFlags"],[6,3,1,"","cudaStreamWaitEvent"],[6,1,1,"","cudaStream_t"],[6,1,1,"","cudaSurfaceBoundaryMode"],[6,1,1,"","cudaSurfaceFormatMode"],[6,1,1,"","cudaSurfaceObject_t"],[6,0,1,"","cudaSurfaceType1D"],[6,0,1,"","cudaSurfaceType1DLayered"],[6,0,1,"","cudaSurfaceType2D"],[6,0,1,"","cudaSurfaceType2DLayered"],[6,0,1,"","cudaSurfaceType3D"],[6,0,1,"","cudaSurfaceTypeCubemap"],[6,0,1,"","cudaSurfaceTypeCubemapLayered"],[6,1,1,"","cudaSynchronizationPolicy"],[6,1,1,"","cudaTextureAddressMode"],[6,1,1,"","cudaTextureDesc"],[6,1,1,"","cudaTextureDesc_v2"],[6,1,1,"","cudaTextureFilterMode"],[6,1,1,"","cudaTextureObject_t"],[6,1,1,"","cudaTextureReadMode"],[6,0,1,"","cudaTextureType1D"],[6,0,1,"","cudaTextureType1DLayered"],[6,0,1,"","cudaTextureType2D"],[6,0,1,"","cudaTextureType2DLayered"],[6,0,1,"","cudaTextureType3D"],[6,0,1,"","cudaTextureTypeCubemap"],[6,0,1,"","cudaTextureTypeCubemapLayered"],[6,3,1,"","cudaThreadExchangeStreamCaptureMode"],[6,1,1,"","cudaUUID_t"],[6,3,1,"","cudaUserObjectCreate"],[6,1,1,"","cudaUserObjectFlags"],[6,3,1,"","cudaUserObjectRelease"],[6,3,1,"","cudaUserObjectRetain"],[6,1,1,"","cudaUserObjectRetainFlags"],[6,1,1,"","cudaUserObject_t"],[6,3,1,"","cudaVDPAUGetDevice"],[6,3,1,"","cudaVDPAUSetVDPAUDevice"],[6,3,1,"","cudaWaitExternalSemaphoresAsync"],[6,3,1,"","make_cudaExtent"],[6,3,1,"","make_cudaPitchedPtr"],[6,3,1,"","make_cudaPos"]],"cuda.cudart.CUuuid":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.CUuuid_st":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.cudaAccessPolicyWindow":[[6,0,1,"","base_ptr"],[6,2,1,"","getPtr"],[6,0,1,"","hitProp"],[6,0,1,"","hitRatio"],[6,0,1,"","missProp"],[6,0,1,"","num_bytes"]],"cuda.cudart.cudaAccessProperty":[[6,0,1,"","cudaAccessPropertyNormal"],[6,0,1,"","cudaAccessPropertyPersisting"],[6,0,1,"","cudaAccessPropertyStreaming"]],"cuda.cudart.cudaArrayMemoryRequirements":[[6,0,1,"","alignment"],[6,2,1,"","getPtr"],[6,0,1,"","reserved"],[6,0,1,"","size"]],"cuda.cudart.cudaArraySparseProperties":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","miptailFirstLevel"],[6,0,1,"","miptailSize"],[6,0,1,"","reserved"],[6,0,1,"","tileExtent"]],"cuda.cudart.cudaArray_const_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaArray_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaCGScope":[[6,0,1,"","cudaCGScopeGrid"],[6,0,1,"","cudaCGScopeInvalid"],[6,0,1,"","cudaCGScopeMultiGrid"]],"cuda.cudart.cudaChannelFormatDesc":[[6,0,1,"","f"],[6,2,1,"","getPtr"],[6,0,1,"","w"],[6,0,1,"","x"],[6,0,1,"","y"],[6,0,1,"","z"]],"cuda.cudart.cudaChannelFormatKind":[[6,0,1,"","cudaChannelFormatKindFloat"],[6,0,1,"","cudaChannelFormatKindNV12"],[6,0,1,"","cudaChannelFormatKindNone"],[6,0,1,"","cudaChannelFormatKindSigned"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed4"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed5"],[6,0,1,"","cudaChannelFormatKindSignedBlockCompressed6H"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X1"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X2"],[6,0,1,"","cudaChannelFormatKindSignedNormalized16X4"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X1"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X2"],[6,0,1,"","cudaChannelFormatKindSignedNormalized8X4"],[6,0,1,"","cudaChannelFormatKindUnsigned"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed1"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed1SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed2"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed2SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed3"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed3SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed4"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed5"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed6H"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed7"],[6,0,1,"","cudaChannelFormatKindUnsignedBlockCompressed7SRGB"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X1"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X2"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized16X4"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X1"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X2"],[6,0,1,"","cudaChannelFormatKindUnsignedNormalized8X4"]],"cuda.cudart.cudaClusterSchedulingPolicy":[[6,0,1,"","cudaClusterSchedulingPolicyDefault"],[6,0,1,"","cudaClusterSchedulingPolicyLoadBalancing"],[6,0,1,"","cudaClusterSchedulingPolicySpread"]],"cuda.cudart.cudaComputeMode":[[6,0,1,"","cudaComputeModeDefault"],[6,0,1,"","cudaComputeModeExclusive"],[6,0,1,"","cudaComputeModeExclusiveProcess"],[6,0,1,"","cudaComputeModeProhibited"]],"cuda.cudart.cudaDeviceAttr":[[6,0,1,"","cudaDevAttrAsyncEngineCount"],[6,0,1,"","cudaDevAttrCanFlushRemoteWrites"],[6,0,1,"","cudaDevAttrCanMapHostMemory"],[6,0,1,"","cudaDevAttrCanUseHostPointerForRegisteredMem"],[6,0,1,"","cudaDevAttrClockRate"],[6,0,1,"","cudaDevAttrClusterLaunch"],[6,0,1,"","cudaDevAttrComputeCapabilityMajor"],[6,0,1,"","cudaDevAttrComputeCapabilityMinor"],[6,0,1,"","cudaDevAttrComputeMode"],[6,0,1,"","cudaDevAttrComputePreemptionSupported"],[6,0,1,"","cudaDevAttrConcurrentKernels"],[6,0,1,"","cudaDevAttrConcurrentManagedAccess"],[6,0,1,"","cudaDevAttrCooperativeLaunch"],[6,0,1,"","cudaDevAttrCooperativeMultiDeviceLaunch"],[6,0,1,"","cudaDevAttrDeferredMappingCudaArraySupported"],[6,0,1,"","cudaDevAttrDirectManagedMemAccessFromHost"],[6,0,1,"","cudaDevAttrEccEnabled"],[6,0,1,"","cudaDevAttrGPUDirectRDMAFlushWritesOptions"],[6,0,1,"","cudaDevAttrGPUDirectRDMASupported"],[6,0,1,"","cudaDevAttrGPUDirectRDMAWritesOrdering"],[6,0,1,"","cudaDevAttrGlobalL1CacheSupported"],[6,0,1,"","cudaDevAttrGlobalMemoryBusWidth"],[6,0,1,"","cudaDevAttrGpuOverlap"],[6,0,1,"","cudaDevAttrHostNativeAtomicSupported"],[6,0,1,"","cudaDevAttrHostRegisterReadOnlySupported"],[6,0,1,"","cudaDevAttrHostRegisterSupported"],[6,0,1,"","cudaDevAttrIntegrated"],[6,0,1,"","cudaDevAttrIsMultiGpuBoard"],[6,0,1,"","cudaDevAttrKernelExecTimeout"],[6,0,1,"","cudaDevAttrL2CacheSize"],[6,0,1,"","cudaDevAttrLocalL1CacheSupported"],[6,0,1,"","cudaDevAttrManagedMemory"],[6,0,1,"","cudaDevAttrMax"],[6,0,1,"","cudaDevAttrMaxAccessPolicyWindowSize"],[6,0,1,"","cudaDevAttrMaxBlockDimX"],[6,0,1,"","cudaDevAttrMaxBlockDimY"],[6,0,1,"","cudaDevAttrMaxBlockDimZ"],[6,0,1,"","cudaDevAttrMaxBlocksPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxGridDimX"],[6,0,1,"","cudaDevAttrMaxGridDimY"],[6,0,1,"","cudaDevAttrMaxGridDimZ"],[6,0,1,"","cudaDevAttrMaxPersistingL2CacheSize"],[6,0,1,"","cudaDevAttrMaxPitch"],[6,0,1,"","cudaDevAttrMaxRegistersPerBlock"],[6,0,1,"","cudaDevAttrMaxRegistersPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerBlock"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerBlockOptin"],[6,0,1,"","cudaDevAttrMaxSharedMemoryPerMultiprocessor"],[6,0,1,"","cudaDevAttrMaxSurface1DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurface1DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurface1DWidth"],[6,0,1,"","cudaDevAttrMaxSurface2DHeight"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredHeight"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurface2DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurface2DWidth"],[6,0,1,"","cudaDevAttrMaxSurface3DDepth"],[6,0,1,"","cudaDevAttrMaxSurface3DHeight"],[6,0,1,"","cudaDevAttrMaxSurface3DWidth"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapLayeredLayers"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapLayeredWidth"],[6,0,1,"","cudaDevAttrMaxSurfaceCubemapWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTexture1DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DLinearWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DMipmappedWidth"],[6,0,1,"","cudaDevAttrMaxTexture1DWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DGatherHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DGatherWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTexture2DLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearPitch"],[6,0,1,"","cudaDevAttrMaxTexture2DLinearWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DMipmappedHeight"],[6,0,1,"","cudaDevAttrMaxTexture2DMipmappedWidth"],[6,0,1,"","cudaDevAttrMaxTexture2DWidth"],[6,0,1,"","cudaDevAttrMaxTexture3DDepth"],[6,0,1,"","cudaDevAttrMaxTexture3DDepthAlt"],[6,0,1,"","cudaDevAttrMaxTexture3DHeight"],[6,0,1,"","cudaDevAttrMaxTexture3DHeightAlt"],[6,0,1,"","cudaDevAttrMaxTexture3DWidth"],[6,0,1,"","cudaDevAttrMaxTexture3DWidthAlt"],[6,0,1,"","cudaDevAttrMaxTextureCubemapLayeredLayers"],[6,0,1,"","cudaDevAttrMaxTextureCubemapLayeredWidth"],[6,0,1,"","cudaDevAttrMaxTextureCubemapWidth"],[6,0,1,"","cudaDevAttrMaxThreadsPerBlock"],[6,0,1,"","cudaDevAttrMaxThreadsPerMultiProcessor"],[6,0,1,"","cudaDevAttrMaxTimelineSemaphoreInteropSupported"],[6,0,1,"","cudaDevAttrMemoryClockRate"],[6,0,1,"","cudaDevAttrMemoryPoolSupportedHandleTypes"],[6,0,1,"","cudaDevAttrMemoryPoolsSupported"],[6,0,1,"","cudaDevAttrMultiGpuBoardGroupID"],[6,0,1,"","cudaDevAttrMultiProcessorCount"],[6,0,1,"","cudaDevAttrPageableMemoryAccess"],[6,0,1,"","cudaDevAttrPageableMemoryAccessUsesHostPageTables"],[6,0,1,"","cudaDevAttrPciBusId"],[6,0,1,"","cudaDevAttrPciDeviceId"],[6,0,1,"","cudaDevAttrPciDomainId"],[6,0,1,"","cudaDevAttrReserved92"],[6,0,1,"","cudaDevAttrReserved93"],[6,0,1,"","cudaDevAttrReserved94"],[6,0,1,"","cudaDevAttrReservedSharedMemoryPerBlock"],[6,0,1,"","cudaDevAttrSingleToDoublePrecisionPerfRatio"],[6,0,1,"","cudaDevAttrSparseCudaArraySupported"],[6,0,1,"","cudaDevAttrStreamPrioritiesSupported"],[6,0,1,"","cudaDevAttrSurfaceAlignment"],[6,0,1,"","cudaDevAttrTccDriver"],[6,0,1,"","cudaDevAttrTextureAlignment"],[6,0,1,"","cudaDevAttrTexturePitchAlignment"],[6,0,1,"","cudaDevAttrTimelineSemaphoreInteropSupported"],[6,0,1,"","cudaDevAttrTotalConstantMemory"],[6,0,1,"","cudaDevAttrUnifiedAddressing"],[6,0,1,"","cudaDevAttrWarpSize"]],"cuda.cudart.cudaDeviceP2PAttr":[[6,0,1,"","cudaDevP2PAttrAccessSupported"],[6,0,1,"","cudaDevP2PAttrCudaArrayAccessSupported"],[6,0,1,"","cudaDevP2PAttrNativeAtomicSupported"],[6,0,1,"","cudaDevP2PAttrPerformanceRank"]],"cuda.cudart.cudaDeviceProp":[[6,0,1,"","ECCEnabled"],[6,0,1,"","accessPolicyMaxWindowSize"],[6,0,1,"","asyncEngineCount"],[6,0,1,"","canMapHostMemory"],[6,0,1,"","canUseHostPointerForRegisteredMem"],[6,0,1,"","clockRate"],[6,0,1,"","computeMode"],[6,0,1,"","computePreemptionSupported"],[6,0,1,"","concurrentKernels"],[6,0,1,"","concurrentManagedAccess"],[6,0,1,"","cooperativeLaunch"],[6,0,1,"","cooperativeMultiDeviceLaunch"],[6,0,1,"","deviceOverlap"],[6,0,1,"","directManagedMemAccessFromHost"],[6,2,1,"","getPtr"],[6,0,1,"","globalL1CacheSupported"],[6,0,1,"","hostNativeAtomicSupported"],[6,0,1,"","integrated"],[6,0,1,"","isMultiGpuBoard"],[6,0,1,"","kernelExecTimeoutEnabled"],[6,0,1,"","l2CacheSize"],[6,0,1,"","localL1CacheSupported"],[6,0,1,"","luid"],[6,0,1,"","luidDeviceNodeMask"],[6,0,1,"","major"],[6,0,1,"","managedMemory"],[6,0,1,"","maxBlocksPerMultiProcessor"],[6,0,1,"","maxGridSize"],[6,0,1,"","maxSurface1D"],[6,0,1,"","maxSurface1DLayered"],[6,0,1,"","maxSurface2D"],[6,0,1,"","maxSurface2DLayered"],[6,0,1,"","maxSurface3D"],[6,0,1,"","maxSurfaceCubemap"],[6,0,1,"","maxSurfaceCubemapLayered"],[6,0,1,"","maxTexture1D"],[6,0,1,"","maxTexture1DLayered"],[6,0,1,"","maxTexture1DLinear"],[6,0,1,"","maxTexture1DMipmap"],[6,0,1,"","maxTexture2D"],[6,0,1,"","maxTexture2DGather"],[6,0,1,"","maxTexture2DLayered"],[6,0,1,"","maxTexture2DLinear"],[6,0,1,"","maxTexture2DMipmap"],[6,0,1,"","maxTexture3D"],[6,0,1,"","maxTexture3DAlt"],[6,0,1,"","maxTextureCubemap"],[6,0,1,"","maxTextureCubemapLayered"],[6,0,1,"","maxThreadsDim"],[6,0,1,"","maxThreadsPerBlock"],[6,0,1,"","maxThreadsPerMultiProcessor"],[6,0,1,"","memPitch"],[6,0,1,"","memoryBusWidth"],[6,0,1,"","memoryClockRate"],[6,0,1,"","minor"],[6,0,1,"","multiGpuBoardGroupID"],[6,0,1,"","multiProcessorCount"],[6,0,1,"","name"],[6,0,1,"","pageableMemoryAccess"],[6,0,1,"","pageableMemoryAccessUsesHostPageTables"],[6,0,1,"","pciBusID"],[6,0,1,"","pciDeviceID"],[6,0,1,"","pciDomainID"],[6,0,1,"","persistingL2CacheMaxSize"],[6,0,1,"","regsPerBlock"],[6,0,1,"","regsPerMultiprocessor"],[6,0,1,"","reservedSharedMemPerBlock"],[6,0,1,"","sharedMemPerBlock"],[6,0,1,"","sharedMemPerBlockOptin"],[6,0,1,"","sharedMemPerMultiprocessor"],[6,0,1,"","singleToDoublePrecisionPerfRatio"],[6,0,1,"","streamPrioritiesSupported"],[6,0,1,"","surfaceAlignment"],[6,0,1,"","tccDriver"],[6,0,1,"","textureAlignment"],[6,0,1,"","texturePitchAlignment"],[6,0,1,"","totalConstMem"],[6,0,1,"","totalGlobalMem"],[6,0,1,"","unifiedAddressing"],[6,0,1,"","uuid"],[6,0,1,"","warpSize"]],"cuda.cudart.cudaEglColorFormat":[[6,0,1,"","cudaEglColorFormatA"],[6,0,1,"","cudaEglColorFormatABGR"],[6,0,1,"","cudaEglColorFormatARGB"],[6,0,1,"","cudaEglColorFormatAYUV"],[6,0,1,"","cudaEglColorFormatAYUV_ER"],[6,0,1,"","cudaEglColorFormatBGRA"],[6,0,1,"","cudaEglColorFormatBayer10BGGR"],[6,0,1,"","cudaEglColorFormatBayer10CCCC"],[6,0,1,"","cudaEglColorFormatBayer10GBRG"],[6,0,1,"","cudaEglColorFormatBayer10GRBG"],[6,0,1,"","cudaEglColorFormatBayer10RGGB"],[6,0,1,"","cudaEglColorFormatBayer12BCCR"],[6,0,1,"","cudaEglColorFormatBayer12BGGR"],[6,0,1,"","cudaEglColorFormatBayer12CBRC"],[6,0,1,"","cudaEglColorFormatBayer12CCCC"],[6,0,1,"","cudaEglColorFormatBayer12CRBC"],[6,0,1,"","cudaEglColorFormatBayer12GBRG"],[6,0,1,"","cudaEglColorFormatBayer12GRBG"],[6,0,1,"","cudaEglColorFormatBayer12RCCB"],[6,0,1,"","cudaEglColorFormatBayer12RGGB"],[6,0,1,"","cudaEglColorFormatBayer14BGGR"],[6,0,1,"","cudaEglColorFormatBayer14GBRG"],[6,0,1,"","cudaEglColorFormatBayer14GRBG"],[6,0,1,"","cudaEglColorFormatBayer14RGGB"],[6,0,1,"","cudaEglColorFormatBayer20BGGR"],[6,0,1,"","cudaEglColorFormatBayer20GBRG"],[6,0,1,"","cudaEglColorFormatBayer20GRBG"],[6,0,1,"","cudaEglColorFormatBayer20RGGB"],[6,0,1,"","cudaEglColorFormatBayerBCCR"],[6,0,1,"","cudaEglColorFormatBayerBGGR"],[6,0,1,"","cudaEglColorFormatBayerCBRC"],[6,0,1,"","cudaEglColorFormatBayerCRBC"],[6,0,1,"","cudaEglColorFormatBayerGBRG"],[6,0,1,"","cudaEglColorFormatBayerGRBG"],[6,0,1,"","cudaEglColorFormatBayerIspBGGR"],[6,0,1,"","cudaEglColorFormatBayerIspGBRG"],[6,0,1,"","cudaEglColorFormatBayerIspGRBG"],[6,0,1,"","cudaEglColorFormatBayerIspRGGB"],[6,0,1,"","cudaEglColorFormatBayerRCCB"],[6,0,1,"","cudaEglColorFormatBayerRGGB"],[6,0,1,"","cudaEglColorFormatL"],[6,0,1,"","cudaEglColorFormatR"],[6,0,1,"","cudaEglColorFormatRG"],[6,0,1,"","cudaEglColorFormatRGBA"],[6,0,1,"","cudaEglColorFormatUYVY422"],[6,0,1,"","cudaEglColorFormatUYVY_ER"],[6,0,1,"","cudaEglColorFormatVYUY"],[6,0,1,"","cudaEglColorFormatVYUY_ER"],[6,0,1,"","cudaEglColorFormatY"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatY10V10U10_422SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY10V10U10_444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY10_709_ER"],[6,0,1,"","cudaEglColorFormatY10_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER"],[6,0,1,"","cudaEglColorFormatY12V12U12_444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatY12_709_ER"],[6,0,1,"","cudaEglColorFormatY12_ER"],[6,0,1,"","cudaEglColorFormatYUV420Planar"],[6,0,1,"","cudaEglColorFormatYUV420Planar_2020"],[6,0,1,"","cudaEglColorFormatYUV420Planar_709"],[6,0,1,"","cudaEglColorFormatYUV420Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatYUV420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUV422Planar"],[6,0,1,"","cudaEglColorFormatYUV422Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV422SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV422SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUV444Planar"],[6,0,1,"","cudaEglColorFormatYUV444Planar_ER"],[6,0,1,"","cudaEglColorFormatYUV444SemiPlanar"],[6,0,1,"","cudaEglColorFormatYUV444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYUVA"],[6,0,1,"","cudaEglColorFormatYUVA_ER"],[6,0,1,"","cudaEglColorFormatYUYV422"],[6,0,1,"","cudaEglColorFormatYUYV_ER"],[6,0,1,"","cudaEglColorFormatYVU420Planar"],[6,0,1,"","cudaEglColorFormatYVU420Planar_2020"],[6,0,1,"","cudaEglColorFormatYVU420Planar_709"],[6,0,1,"","cudaEglColorFormatYVU420Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_2020"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_709"],[6,0,1,"","cudaEglColorFormatYVU420SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVU422Planar"],[6,0,1,"","cudaEglColorFormatYVU422Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU422SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU422SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVU444Planar"],[6,0,1,"","cudaEglColorFormatYVU444Planar_ER"],[6,0,1,"","cudaEglColorFormatYVU444SemiPlanar"],[6,0,1,"","cudaEglColorFormatYVU444SemiPlanar_ER"],[6,0,1,"","cudaEglColorFormatYVYU"],[6,0,1,"","cudaEglColorFormatYVYU_ER"],[6,0,1,"","cudaEglColorFormatY_709_ER"],[6,0,1,"","cudaEglColorFormatY_ER"]],"cuda.cudart.cudaEglFrame":[[6,0,1,"","eglColorFormat"],[6,0,1,"","frame"],[6,0,1,"","frameType"],[6,2,1,"","getPtr"],[6,0,1,"","planeCount"],[6,0,1,"","planeDesc"]],"cuda.cudart.cudaEglFrameType":[[6,0,1,"","cudaEglFrameTypeArray"],[6,0,1,"","cudaEglFrameTypePitch"]],"cuda.cudart.cudaEglFrame_st":[[6,0,1,"","eglColorFormat"],[6,0,1,"","frame"],[6,0,1,"","frameType"],[6,2,1,"","getPtr"],[6,0,1,"","planeCount"],[6,0,1,"","planeDesc"]],"cuda.cudart.cudaEglPlaneDesc":[[6,0,1,"","channelDesc"],[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","numChannels"],[6,0,1,"","pitch"],[6,0,1,"","reserved"],[6,0,1,"","width"]],"cuda.cudart.cudaEglPlaneDesc_st":[[6,0,1,"","channelDesc"],[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","numChannels"],[6,0,1,"","pitch"],[6,0,1,"","reserved"],[6,0,1,"","width"]],"cuda.cudart.cudaEglResourceLocationFlags":[[6,0,1,"","cudaEglResourceLocationSysmem"],[6,0,1,"","cudaEglResourceLocationVidmem"]],"cuda.cudart.cudaEglStreamConnection":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaError_t":[[6,0,1,"","cudaErrorAddressOfConstant"],[6,0,1,"","cudaErrorAlreadyAcquired"],[6,0,1,"","cudaErrorAlreadyMapped"],[6,0,1,"","cudaErrorApiFailureBase"],[6,0,1,"","cudaErrorArrayIsMapped"],[6,0,1,"","cudaErrorAssert"],[6,0,1,"","cudaErrorCallRequiresNewerDriver"],[6,0,1,"","cudaErrorCapturedEvent"],[6,0,1,"","cudaErrorCompatNotSupportedOnDevice"],[6,0,1,"","cudaErrorContextIsDestroyed"],[6,0,1,"","cudaErrorCooperativeLaunchTooLarge"],[6,0,1,"","cudaErrorCudartUnloading"],[6,0,1,"","cudaErrorDeviceAlreadyInUse"],[6,0,1,"","cudaErrorDeviceNotLicensed"],[6,0,1,"","cudaErrorDeviceUninitialized"],[6,0,1,"","cudaErrorDevicesUnavailable"],[6,0,1,"","cudaErrorDuplicateSurfaceName"],[6,0,1,"","cudaErrorDuplicateTextureName"],[6,0,1,"","cudaErrorDuplicateVariableName"],[6,0,1,"","cudaErrorECCUncorrectable"],[6,0,1,"","cudaErrorExternalDevice"],[6,0,1,"","cudaErrorFileNotFound"],[6,0,1,"","cudaErrorGraphExecUpdateFailure"],[6,0,1,"","cudaErrorHardwareStackError"],[6,0,1,"","cudaErrorHostMemoryAlreadyRegistered"],[6,0,1,"","cudaErrorHostMemoryNotRegistered"],[6,0,1,"","cudaErrorIllegalAddress"],[6,0,1,"","cudaErrorIllegalInstruction"],[6,0,1,"","cudaErrorIllegalState"],[6,0,1,"","cudaErrorIncompatibleDriverContext"],[6,0,1,"","cudaErrorInitializationError"],[6,0,1,"","cudaErrorInsufficientDriver"],[6,0,1,"","cudaErrorInvalidAddressSpace"],[6,0,1,"","cudaErrorInvalidChannelDescriptor"],[6,0,1,"","cudaErrorInvalidClusterSize"],[6,0,1,"","cudaErrorInvalidConfiguration"],[6,0,1,"","cudaErrorInvalidDevice"],[6,0,1,"","cudaErrorInvalidDeviceFunction"],[6,0,1,"","cudaErrorInvalidDevicePointer"],[6,0,1,"","cudaErrorInvalidFilterSetting"],[6,0,1,"","cudaErrorInvalidGraphicsContext"],[6,0,1,"","cudaErrorInvalidHostPointer"],[6,0,1,"","cudaErrorInvalidKernelImage"],[6,0,1,"","cudaErrorInvalidMemcpyDirection"],[6,0,1,"","cudaErrorInvalidNormSetting"],[6,0,1,"","cudaErrorInvalidPc"],[6,0,1,"","cudaErrorInvalidPitchValue"],[6,0,1,"","cudaErrorInvalidPtx"],[6,0,1,"","cudaErrorInvalidResourceHandle"],[6,0,1,"","cudaErrorInvalidSource"],[6,0,1,"","cudaErrorInvalidSurface"],[6,0,1,"","cudaErrorInvalidSymbol"],[6,0,1,"","cudaErrorInvalidTexture"],[6,0,1,"","cudaErrorInvalidTextureBinding"],[6,0,1,"","cudaErrorInvalidValue"],[6,0,1,"","cudaErrorJitCompilationDisabled"],[6,0,1,"","cudaErrorJitCompilerNotFound"],[6,0,1,"","cudaErrorLaunchFailure"],[6,0,1,"","cudaErrorLaunchFileScopedSurf"],[6,0,1,"","cudaErrorLaunchFileScopedTex"],[6,0,1,"","cudaErrorLaunchIncompatibleTexturing"],[6,0,1,"","cudaErrorLaunchMaxDepthExceeded"],[6,0,1,"","cudaErrorLaunchOutOfResources"],[6,0,1,"","cudaErrorLaunchPendingCountExceeded"],[6,0,1,"","cudaErrorLaunchTimeout"],[6,0,1,"","cudaErrorMapBufferObjectFailed"],[6,0,1,"","cudaErrorMemoryAllocation"],[6,0,1,"","cudaErrorMemoryValueTooLarge"],[6,0,1,"","cudaErrorMisalignedAddress"],[6,0,1,"","cudaErrorMissingConfiguration"],[6,0,1,"","cudaErrorMixedDeviceExecution"],[6,0,1,"","cudaErrorMpsClientTerminated"],[6,0,1,"","cudaErrorMpsConnectionFailed"],[6,0,1,"","cudaErrorMpsMaxClientsReached"],[6,0,1,"","cudaErrorMpsMaxConnectionsReached"],[6,0,1,"","cudaErrorMpsRpcFailure"],[6,0,1,"","cudaErrorMpsServerNotReady"],[6,0,1,"","cudaErrorNoDevice"],[6,0,1,"","cudaErrorNoKernelImageForDevice"],[6,0,1,"","cudaErrorNotMapped"],[6,0,1,"","cudaErrorNotMappedAsArray"],[6,0,1,"","cudaErrorNotMappedAsPointer"],[6,0,1,"","cudaErrorNotPermitted"],[6,0,1,"","cudaErrorNotReady"],[6,0,1,"","cudaErrorNotSupported"],[6,0,1,"","cudaErrorNotYetImplemented"],[6,0,1,"","cudaErrorNvlinkUncorrectable"],[6,0,1,"","cudaErrorOperatingSystem"],[6,0,1,"","cudaErrorPeerAccessAlreadyEnabled"],[6,0,1,"","cudaErrorPeerAccessNotEnabled"],[6,0,1,"","cudaErrorPeerAccessUnsupported"],[6,0,1,"","cudaErrorPriorLaunchFailure"],[6,0,1,"","cudaErrorProfilerAlreadyStarted"],[6,0,1,"","cudaErrorProfilerAlreadyStopped"],[6,0,1,"","cudaErrorProfilerDisabled"],[6,0,1,"","cudaErrorProfilerNotInitialized"],[6,0,1,"","cudaErrorSetOnActiveProcess"],[6,0,1,"","cudaErrorSharedObjectInitFailed"],[6,0,1,"","cudaErrorSharedObjectSymbolNotFound"],[6,0,1,"","cudaErrorSoftwareValidityNotEstablished"],[6,0,1,"","cudaErrorStartupFailure"],[6,0,1,"","cudaErrorStreamCaptureImplicit"],[6,0,1,"","cudaErrorStreamCaptureInvalidated"],[6,0,1,"","cudaErrorStreamCaptureIsolation"],[6,0,1,"","cudaErrorStreamCaptureMerge"],[6,0,1,"","cudaErrorStreamCaptureUnjoined"],[6,0,1,"","cudaErrorStreamCaptureUnmatched"],[6,0,1,"","cudaErrorStreamCaptureUnsupported"],[6,0,1,"","cudaErrorStreamCaptureWrongThread"],[6,0,1,"","cudaErrorStubLibrary"],[6,0,1,"","cudaErrorSymbolNotFound"],[6,0,1,"","cudaErrorSyncDepthExceeded"],[6,0,1,"","cudaErrorSynchronizationError"],[6,0,1,"","cudaErrorSystemDriverMismatch"],[6,0,1,"","cudaErrorSystemNotReady"],[6,0,1,"","cudaErrorTextureFetchFailed"],[6,0,1,"","cudaErrorTextureNotBound"],[6,0,1,"","cudaErrorTimeout"],[6,0,1,"","cudaErrorTooManyPeers"],[6,0,1,"","cudaErrorUnknown"],[6,0,1,"","cudaErrorUnmapBufferObjectFailed"],[6,0,1,"","cudaErrorUnsupportedExecAffinity"],[6,0,1,"","cudaErrorUnsupportedLimit"],[6,0,1,"","cudaErrorUnsupportedPtxVersion"],[6,0,1,"","cudaSuccess"]],"cuda.cudart.cudaEvent_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaExtent":[[6,0,1,"","depth"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","width"]],"cuda.cudart.cudaExternalMemoryBufferDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","offset"],[6,0,1,"","size"]],"cuda.cudart.cudaExternalMemoryHandleDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","handle"],[6,0,1,"","size"],[6,0,1,"","type"]],"cuda.cudart.cudaExternalMemoryHandleType":[[6,0,1,"","cudaExternalMemoryHandleTypeD3D11Resource"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D11ResourceKmt"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D12Heap"],[6,0,1,"","cudaExternalMemoryHandleTypeD3D12Resource"],[6,0,1,"","cudaExternalMemoryHandleTypeNvSciBuf"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueFd"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueWin32"],[6,0,1,"","cudaExternalMemoryHandleTypeOpaqueWin32Kmt"]],"cuda.cudart.cudaExternalMemoryMipmappedArrayDesc":[[6,0,1,"","extent"],[6,0,1,"","flags"],[6,0,1,"","formatDesc"],[6,2,1,"","getPtr"],[6,0,1,"","numLevels"],[6,0,1,"","offset"]],"cuda.cudart.cudaExternalMemory_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaExternalSemaphoreHandleDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","handle"],[6,0,1,"","type"]],"cuda.cudart.cudaExternalSemaphoreHandleType":[[6,0,1,"","cudaExternalSemaphoreHandleTypeD3D11Fence"],[6,0,1,"","cudaExternalSemaphoreHandleTypeD3D12Fence"],[6,0,1,"","cudaExternalSemaphoreHandleTypeKeyedMutex"],[6,0,1,"","cudaExternalSemaphoreHandleTypeKeyedMutexKmt"],[6,0,1,"","cudaExternalSemaphoreHandleTypeNvSciSync"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueFd"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueWin32"],[6,0,1,"","cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt"],[6,0,1,"","cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd"],[6,0,1,"","cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32"]],"cuda.cudart.cudaExternalSemaphoreSignalNodeParams":[[6,0,1,"","extSemArray"],[6,2,1,"","getPtr"],[6,0,1,"","numExtSems"],[6,0,1,"","paramsArray"]],"cuda.cudart.cudaExternalSemaphoreSignalParams":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","params"],[6,0,1,"","reserved"]],"cuda.cudart.cudaExternalSemaphoreWaitNodeParams":[[6,0,1,"","extSemArray"],[6,2,1,"","getPtr"],[6,0,1,"","numExtSems"],[6,0,1,"","paramsArray"]],"cuda.cudart.cudaExternalSemaphoreWaitParams":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","params"],[6,0,1,"","reserved"]],"cuda.cudart.cudaExternalSemaphore_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesOptions":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesOptionHost"],[6,0,1,"","cudaFlushGPUDirectRDMAWritesOptionMemOps"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesScope":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesToAllDevices"],[6,0,1,"","cudaFlushGPUDirectRDMAWritesToOwner"]],"cuda.cudart.cudaFlushGPUDirectRDMAWritesTarget":[[6,0,1,"","cudaFlushGPUDirectRDMAWritesTargetCurrentDevice"]],"cuda.cudart.cudaFuncAttribute":[[6,0,1,"","cudaFuncAttributeClusterDimMustBeSet"],[6,0,1,"","cudaFuncAttributeClusterSchedulingPolicyPreference"],[6,0,1,"","cudaFuncAttributeMax"],[6,0,1,"","cudaFuncAttributeMaxDynamicSharedMemorySize"],[6,0,1,"","cudaFuncAttributeNonPortableClusterSizeAllowed"],[6,0,1,"","cudaFuncAttributePreferredSharedMemoryCarveout"],[6,0,1,"","cudaFuncAttributeRequiredClusterDepth"],[6,0,1,"","cudaFuncAttributeRequiredClusterHeight"],[6,0,1,"","cudaFuncAttributeRequiredClusterWidth"]],"cuda.cudart.cudaFuncAttributes":[[6,0,1,"","binaryVersion"],[6,0,1,"","cacheModeCA"],[6,0,1,"","constSizeBytes"],[6,2,1,"","getPtr"],[6,0,1,"","localSizeBytes"],[6,0,1,"","maxDynamicSharedSizeBytes"],[6,0,1,"","maxThreadsPerBlock"],[6,0,1,"","numRegs"],[6,0,1,"","preferredShmemCarveout"],[6,0,1,"","ptxVersion"],[6,0,1,"","sharedSizeBytes"]],"cuda.cudart.cudaFuncCache":[[6,0,1,"","cudaFuncCachePreferEqual"],[6,0,1,"","cudaFuncCachePreferL1"],[6,0,1,"","cudaFuncCachePreferNone"],[6,0,1,"","cudaFuncCachePreferShared"]],"cuda.cudart.cudaFunction_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGLDeviceList":[[6,0,1,"","cudaGLDeviceListAll"],[6,0,1,"","cudaGLDeviceListCurrentFrame"],[6,0,1,"","cudaGLDeviceListNextFrame"]],"cuda.cudart.cudaGPUDirectRDMAWritesOrdering":[[6,0,1,"","cudaGPUDirectRDMAWritesOrderingAllDevices"],[6,0,1,"","cudaGPUDirectRDMAWritesOrderingNone"],[6,0,1,"","cudaGPUDirectRDMAWritesOrderingOwner"]],"cuda.cudart.cudaGetDriverEntryPointFlags":[[6,0,1,"","cudaEnableDefault"],[6,0,1,"","cudaEnableLegacyStream"],[6,0,1,"","cudaEnablePerThreadDefaultStream"]],"cuda.cudart.cudaGraphDebugDotFlags":[[6,0,1,"","cudaGraphDebugDotFlagsEventNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsExtSemasSignalNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsExtSemasWaitNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsHandles"],[6,0,1,"","cudaGraphDebugDotFlagsHostNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsKernelNodeAttributes"],[6,0,1,"","cudaGraphDebugDotFlagsKernelNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsMemcpyNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsMemsetNodeParams"],[6,0,1,"","cudaGraphDebugDotFlagsVerbose"]],"cuda.cudart.cudaGraphExecUpdateResult":[[6,0,1,"","cudaGraphExecUpdateError"],[6,0,1,"","cudaGraphExecUpdateErrorAttributesChanged"],[6,0,1,"","cudaGraphExecUpdateErrorFunctionChanged"],[6,0,1,"","cudaGraphExecUpdateErrorNodeTypeChanged"],[6,0,1,"","cudaGraphExecUpdateErrorNotSupported"],[6,0,1,"","cudaGraphExecUpdateErrorParametersChanged"],[6,0,1,"","cudaGraphExecUpdateErrorTopologyChanged"],[6,0,1,"","cudaGraphExecUpdateErrorUnsupportedFunctionChange"],[6,0,1,"","cudaGraphExecUpdateSuccess"]],"cuda.cudart.cudaGraphExec_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraphInstantiateFlags":[[6,0,1,"","cudaGraphInstantiateFlagAutoFreeOnLaunch"],[6,0,1,"","cudaGraphInstantiateFlagUseNodePriority"]],"cuda.cudart.cudaGraphMemAttributeType":[[6,0,1,"","cudaGraphMemAttrReservedMemCurrent"],[6,0,1,"","cudaGraphMemAttrReservedMemHigh"],[6,0,1,"","cudaGraphMemAttrUsedMemCurrent"],[6,0,1,"","cudaGraphMemAttrUsedMemHigh"]],"cuda.cudart.cudaGraphNodeType":[[6,0,1,"","cudaGraphNodeTypeCount"],[6,0,1,"","cudaGraphNodeTypeEmpty"],[6,0,1,"","cudaGraphNodeTypeEventRecord"],[6,0,1,"","cudaGraphNodeTypeExtSemaphoreSignal"],[6,0,1,"","cudaGraphNodeTypeExtSemaphoreWait"],[6,0,1,"","cudaGraphNodeTypeGraph"],[6,0,1,"","cudaGraphNodeTypeHost"],[6,0,1,"","cudaGraphNodeTypeKernel"],[6,0,1,"","cudaGraphNodeTypeMemAlloc"],[6,0,1,"","cudaGraphNodeTypeMemFree"],[6,0,1,"","cudaGraphNodeTypeMemcpy"],[6,0,1,"","cudaGraphNodeTypeMemset"],[6,0,1,"","cudaGraphNodeTypeWaitEvent"]],"cuda.cudart.cudaGraphNode_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraph_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaGraphicsCubeFace":[[6,0,1,"","cudaGraphicsCubeFaceNegativeX"],[6,0,1,"","cudaGraphicsCubeFaceNegativeY"],[6,0,1,"","cudaGraphicsCubeFaceNegativeZ"],[6,0,1,"","cudaGraphicsCubeFacePositiveX"],[6,0,1,"","cudaGraphicsCubeFacePositiveY"],[6,0,1,"","cudaGraphicsCubeFacePositiveZ"]],"cuda.cudart.cudaGraphicsMapFlags":[[6,0,1,"","cudaGraphicsMapFlagsNone"],[6,0,1,"","cudaGraphicsMapFlagsReadOnly"],[6,0,1,"","cudaGraphicsMapFlagsWriteDiscard"]],"cuda.cudart.cudaGraphicsRegisterFlags":[[6,0,1,"","cudaGraphicsRegisterFlagsNone"],[6,0,1,"","cudaGraphicsRegisterFlagsReadOnly"],[6,0,1,"","cudaGraphicsRegisterFlagsSurfaceLoadStore"],[6,0,1,"","cudaGraphicsRegisterFlagsTextureGather"],[6,0,1,"","cudaGraphicsRegisterFlagsWriteDiscard"]],"cuda.cudart.cudaGraphicsResource_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaHostFn_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaHostNodeParams":[[6,0,1,"","fn"],[6,2,1,"","getPtr"],[6,0,1,"","userData"]],"cuda.cudart.cudaIpcEventHandle_st":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcEventHandle_t":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcMemHandle_st":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaIpcMemHandle_t":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaKernelNodeParams":[[6,0,1,"","blockDim"],[6,0,1,"","extra"],[6,0,1,"","func"],[6,2,1,"","getPtr"],[6,0,1,"","gridDim"],[6,0,1,"","kernelParams"],[6,0,1,"","sharedMemBytes"]],"cuda.cudart.cudaLaunchAttribute":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","val"]],"cuda.cudart.cudaLaunchAttributeID":[[6,0,1,"","cudaLaunchAttributeAccessPolicyWindow"],[6,0,1,"","cudaLaunchAttributeClusterDimension"],[6,0,1,"","cudaLaunchAttributeClusterSchedulingPolicyPreference"],[6,0,1,"","cudaLaunchAttributeCooperative"],[6,0,1,"","cudaLaunchAttributeIgnore"],[6,0,1,"","cudaLaunchAttributePriority"],[6,0,1,"","cudaLaunchAttributeProgrammaticEvent"],[6,0,1,"","cudaLaunchAttributeProgrammaticStreamSerialization"],[6,0,1,"","cudaLaunchAttributeSynchronizationPolicy"]],"cuda.cudart.cudaLaunchAttributeValue":[[6,0,1,"id28","accessPolicyWindow"],[6,0,1,"id31","clusterDim"],[6,0,1,"id32","clusterSchedulingPolicyPreference"],[6,0,1,"id29","cooperative"],[6,2,1,"id36","getPtr"],[6,0,1,"id27","pad"],[6,0,1,"id35","priority"],[6,0,1,"id34","programmaticEvent"],[6,0,1,"id33","programmaticStreamSerializationAllowed"],[6,0,1,"id30","syncPolicy"]],"cuda.cudart.cudaLaunchAttribute_st":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","val"]],"cuda.cudart.cudaLimit":[[6,0,1,"","cudaLimitDevRuntimePendingLaunchCount"],[6,0,1,"","cudaLimitDevRuntimeSyncDepth"],[6,0,1,"","cudaLimitMallocHeapSize"],[6,0,1,"","cudaLimitMaxL2FetchGranularity"],[6,0,1,"","cudaLimitPersistingL2CacheSize"],[6,0,1,"","cudaLimitPrintfFifoSize"],[6,0,1,"","cudaLimitStackSize"]],"cuda.cudart.cudaMemAccessDesc":[[6,0,1,"","flags"],[6,2,1,"","getPtr"],[6,0,1,"","location"]],"cuda.cudart.cudaMemAccessFlags":[[6,0,1,"","cudaMemAccessFlagsProtNone"],[6,0,1,"","cudaMemAccessFlagsProtRead"],[6,0,1,"","cudaMemAccessFlagsProtReadWrite"]],"cuda.cudart.cudaMemAllocNodeParams":[[6,0,1,"","accessDescCount"],[6,0,1,"","accessDescs"],[6,0,1,"","bytesize"],[6,0,1,"","dptr"],[6,2,1,"","getPtr"],[6,0,1,"","poolProps"]],"cuda.cudart.cudaMemAllocationHandleType":[[6,0,1,"","cudaMemHandleTypeNone"],[6,0,1,"","cudaMemHandleTypePosixFileDescriptor"],[6,0,1,"","cudaMemHandleTypeWin32"],[6,0,1,"","cudaMemHandleTypeWin32Kmt"]],"cuda.cudart.cudaMemAllocationType":[[6,0,1,"","cudaMemAllocationTypeInvalid"],[6,0,1,"","cudaMemAllocationTypeMax"],[6,0,1,"","cudaMemAllocationTypePinned"]],"cuda.cudart.cudaMemLocation":[[6,2,1,"","getPtr"],[6,0,1,"","id"],[6,0,1,"","type"]],"cuda.cudart.cudaMemLocationType":[[6,0,1,"","cudaMemLocationTypeDevice"],[6,0,1,"","cudaMemLocationTypeInvalid"]],"cuda.cudart.cudaMemPoolAttr":[[6,0,1,"","cudaMemPoolAttrReleaseThreshold"],[6,0,1,"","cudaMemPoolAttrReservedMemCurrent"],[6,0,1,"","cudaMemPoolAttrReservedMemHigh"],[6,0,1,"","cudaMemPoolAttrUsedMemCurrent"],[6,0,1,"","cudaMemPoolAttrUsedMemHigh"],[6,0,1,"","cudaMemPoolReuseAllowInternalDependencies"],[6,0,1,"","cudaMemPoolReuseAllowOpportunistic"],[6,0,1,"","cudaMemPoolReuseFollowEventDependencies"]],"cuda.cudart.cudaMemPoolProps":[[6,0,1,"","allocType"],[6,2,1,"","getPtr"],[6,0,1,"","handleTypes"],[6,0,1,"","location"],[6,0,1,"","reserved"],[6,0,1,"","win32SecurityAttributes"]],"cuda.cudart.cudaMemPoolPtrExportData":[[6,2,1,"","getPtr"],[6,0,1,"","reserved"]],"cuda.cudart.cudaMemPool_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaMemRangeAttribute":[[6,0,1,"","cudaMemRangeAttributeAccessedBy"],[6,0,1,"","cudaMemRangeAttributeLastPrefetchLocation"],[6,0,1,"","cudaMemRangeAttributePreferredLocation"],[6,0,1,"","cudaMemRangeAttributeReadMostly"]],"cuda.cudart.cudaMemcpy3DParms":[[6,0,1,"","dstArray"],[6,0,1,"","dstPos"],[6,0,1,"","dstPtr"],[6,0,1,"","extent"],[6,2,1,"","getPtr"],[6,0,1,"","kind"],[6,0,1,"","srcArray"],[6,0,1,"","srcPos"],[6,0,1,"","srcPtr"]],"cuda.cudart.cudaMemcpy3DPeerParms":[[6,0,1,"","dstArray"],[6,0,1,"","dstDevice"],[6,0,1,"","dstPos"],[6,0,1,"","dstPtr"],[6,0,1,"","extent"],[6,2,1,"","getPtr"],[6,0,1,"","srcArray"],[6,0,1,"","srcDevice"],[6,0,1,"","srcPos"],[6,0,1,"","srcPtr"]],"cuda.cudart.cudaMemcpyKind":[[6,0,1,"","cudaMemcpyDefault"],[6,0,1,"","cudaMemcpyDeviceToDevice"],[6,0,1,"","cudaMemcpyDeviceToHost"],[6,0,1,"","cudaMemcpyHostToDevice"],[6,0,1,"","cudaMemcpyHostToHost"]],"cuda.cudart.cudaMemoryAdvise":[[6,0,1,"","cudaMemAdviseSetAccessedBy"],[6,0,1,"","cudaMemAdviseSetPreferredLocation"],[6,0,1,"","cudaMemAdviseSetReadMostly"],[6,0,1,"","cudaMemAdviseUnsetAccessedBy"],[6,0,1,"","cudaMemAdviseUnsetPreferredLocation"],[6,0,1,"","cudaMemAdviseUnsetReadMostly"]],"cuda.cudart.cudaMemoryType":[[6,0,1,"","cudaMemoryTypeDevice"],[6,0,1,"","cudaMemoryTypeHost"],[6,0,1,"","cudaMemoryTypeManaged"],[6,0,1,"","cudaMemoryTypeUnregistered"]],"cuda.cudart.cudaMemsetParams":[[6,0,1,"","dst"],[6,0,1,"","elementSize"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","pitch"],[6,0,1,"","value"],[6,0,1,"","width"]],"cuda.cudart.cudaMipmappedArray_const_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaMipmappedArray_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaOutputMode_t":[[6,0,1,"","cudaCSV"],[6,0,1,"","cudaKeyValuePair"]],"cuda.cudart.cudaPitchedPtr":[[6,2,1,"","getPtr"],[6,0,1,"","pitch"],[6,0,1,"","ptr"],[6,0,1,"","xsize"],[6,0,1,"","ysize"]],"cuda.cudart.cudaPointerAttributes":[[6,0,1,"","device"],[6,0,1,"","devicePointer"],[6,2,1,"","getPtr"],[6,0,1,"","hostPointer"],[6,0,1,"","type"]],"cuda.cudart.cudaPos":[[6,2,1,"","getPtr"],[6,0,1,"","x"],[6,0,1,"","y"],[6,0,1,"","z"]],"cuda.cudart.cudaResourceDesc":[[6,2,1,"","getPtr"],[6,0,1,"","res"],[6,0,1,"","resType"]],"cuda.cudart.cudaResourceType":[[6,0,1,"","cudaResourceTypeArray"],[6,0,1,"","cudaResourceTypeLinear"],[6,0,1,"","cudaResourceTypeMipmappedArray"],[6,0,1,"","cudaResourceTypePitch2D"]],"cuda.cudart.cudaResourceViewDesc":[[6,0,1,"","depth"],[6,0,1,"","firstLayer"],[6,0,1,"","firstMipmapLevel"],[6,0,1,"","format"],[6,2,1,"","getPtr"],[6,0,1,"","height"],[6,0,1,"","lastLayer"],[6,0,1,"","lastMipmapLevel"],[6,0,1,"","width"]],"cuda.cudart.cudaResourceViewFormat":[[6,0,1,"","cudaResViewFormatFloat1"],[6,0,1,"","cudaResViewFormatFloat2"],[6,0,1,"","cudaResViewFormatFloat4"],[6,0,1,"","cudaResViewFormatHalf1"],[6,0,1,"","cudaResViewFormatHalf2"],[6,0,1,"","cudaResViewFormatHalf4"],[6,0,1,"","cudaResViewFormatNone"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed4"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed5"],[6,0,1,"","cudaResViewFormatSignedBlockCompressed6H"],[6,0,1,"","cudaResViewFormatSignedChar1"],[6,0,1,"","cudaResViewFormatSignedChar2"],[6,0,1,"","cudaResViewFormatSignedChar4"],[6,0,1,"","cudaResViewFormatSignedInt1"],[6,0,1,"","cudaResViewFormatSignedInt2"],[6,0,1,"","cudaResViewFormatSignedInt4"],[6,0,1,"","cudaResViewFormatSignedShort1"],[6,0,1,"","cudaResViewFormatSignedShort2"],[6,0,1,"","cudaResViewFormatSignedShort4"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed1"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed2"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed3"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed4"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed5"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed6H"],[6,0,1,"","cudaResViewFormatUnsignedBlockCompressed7"],[6,0,1,"","cudaResViewFormatUnsignedChar1"],[6,0,1,"","cudaResViewFormatUnsignedChar2"],[6,0,1,"","cudaResViewFormatUnsignedChar4"],[6,0,1,"","cudaResViewFormatUnsignedInt1"],[6,0,1,"","cudaResViewFormatUnsignedInt2"],[6,0,1,"","cudaResViewFormatUnsignedInt4"],[6,0,1,"","cudaResViewFormatUnsignedShort1"],[6,0,1,"","cudaResViewFormatUnsignedShort2"],[6,0,1,"","cudaResViewFormatUnsignedShort4"]],"cuda.cudart.cudaSharedCarveout":[[6,0,1,"","cudaSharedmemCarveoutDefault"],[6,0,1,"","cudaSharedmemCarveoutMaxL1"],[6,0,1,"","cudaSharedmemCarveoutMaxShared"]],"cuda.cudart.cudaSharedMemConfig":[[6,0,1,"","cudaSharedMemBankSizeDefault"],[6,0,1,"","cudaSharedMemBankSizeEightByte"],[6,0,1,"","cudaSharedMemBankSizeFourByte"]],"cuda.cudart.cudaStreamCallback_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaStreamCaptureMode":[[6,0,1,"","cudaStreamCaptureModeGlobal"],[6,0,1,"","cudaStreamCaptureModeRelaxed"],[6,0,1,"","cudaStreamCaptureModeThreadLocal"]],"cuda.cudart.cudaStreamCaptureStatus":[[6,0,1,"","cudaStreamCaptureStatusActive"],[6,0,1,"","cudaStreamCaptureStatusInvalidated"],[6,0,1,"","cudaStreamCaptureStatusNone"]],"cuda.cudart.cudaStreamUpdateCaptureDependenciesFlags":[[6,0,1,"","cudaStreamAddCaptureDependencies"],[6,0,1,"","cudaStreamSetCaptureDependencies"]],"cuda.cudart.cudaStream_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaSurfaceBoundaryMode":[[6,0,1,"","cudaBoundaryModeClamp"],[6,0,1,"","cudaBoundaryModeTrap"],[6,0,1,"","cudaBoundaryModeZero"]],"cuda.cudart.cudaSurfaceFormatMode":[[6,0,1,"","cudaFormatModeAuto"],[6,0,1,"","cudaFormatModeForced"]],"cuda.cudart.cudaSurfaceObject_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaSynchronizationPolicy":[[6,0,1,"","cudaSyncPolicyAuto"],[6,0,1,"","cudaSyncPolicyBlockingSync"],[6,0,1,"","cudaSyncPolicySpin"],[6,0,1,"","cudaSyncPolicyYield"]],"cuda.cudart.cudaTextureAddressMode":[[6,0,1,"","cudaAddressModeBorder"],[6,0,1,"","cudaAddressModeClamp"],[6,0,1,"","cudaAddressModeMirror"],[6,0,1,"","cudaAddressModeWrap"]],"cuda.cudart.cudaTextureDesc":[[6,0,1,"","addressMode"],[6,0,1,"","borderColor"],[6,0,1,"","disableTrilinearOptimization"],[6,0,1,"","filterMode"],[6,2,1,"","getPtr"],[6,0,1,"","maxAnisotropy"],[6,0,1,"","maxMipmapLevelClamp"],[6,0,1,"","minMipmapLevelClamp"],[6,0,1,"","mipmapFilterMode"],[6,0,1,"","mipmapLevelBias"],[6,0,1,"","normalizedCoords"],[6,0,1,"","readMode"],[6,0,1,"","sRGB"]],"cuda.cudart.cudaTextureDesc_v2":[[6,0,1,"","addressMode"],[6,0,1,"","borderColor"],[6,0,1,"","disableTrilinearOptimization"],[6,0,1,"","filterMode"],[6,2,1,"","getPtr"],[6,0,1,"","maxAnisotropy"],[6,0,1,"","maxMipmapLevelClamp"],[6,0,1,"","minMipmapLevelClamp"],[6,0,1,"","mipmapFilterMode"],[6,0,1,"","mipmapLevelBias"],[6,0,1,"","normalizedCoords"],[6,0,1,"","readMode"],[6,0,1,"","sRGB"],[6,0,1,"","seamlessCubemap"]],"cuda.cudart.cudaTextureFilterMode":[[6,0,1,"","cudaFilterModeLinear"],[6,0,1,"","cudaFilterModePoint"]],"cuda.cudart.cudaTextureObject_t":[[6,2,1,"","getPtr"]],"cuda.cudart.cudaTextureReadMode":[[6,0,1,"","cudaReadModeElementType"],[6,0,1,"","cudaReadModeNormalizedFloat"]],"cuda.cudart.cudaUUID_t":[[6,0,1,"","bytes"],[6,2,1,"","getPtr"]],"cuda.cudart.cudaUserObjectFlags":[[6,0,1,"","cudaUserObjectNoDestructorSync"]],"cuda.cudart.cudaUserObjectRetainFlags":[[6,0,1,"","cudaGraphUserObjectMove"]],"cuda.cudart.cudaUserObject_t":[[6,2,1,"","getPtr"]],"cuda.nvrtc":[[7,3,1,"","nvrtcAddNameExpression"],[7,3,1,"","nvrtcCompileProgram"],[7,3,1,"","nvrtcCreateProgram"],[7,3,1,"","nvrtcDestroyProgram"],[7,3,1,"","nvrtcGetCUBIN"],[7,3,1,"","nvrtcGetCUBINSize"],[7,3,1,"","nvrtcGetErrorString"],[7,3,1,"","nvrtcGetLoweredName"],[7,3,1,"","nvrtcGetNVVM"],[7,3,1,"","nvrtcGetNVVMSize"],[7,3,1,"","nvrtcGetNumSupportedArchs"],[7,3,1,"","nvrtcGetPTX"],[7,3,1,"","nvrtcGetPTXSize"],[7,3,1,"","nvrtcGetProgramLog"],[7,3,1,"","nvrtcGetProgramLogSize"],[7,3,1,"","nvrtcGetSupportedArchs"],[7,1,1,"","nvrtcProgram"],[7,1,1,"","nvrtcResult"],[7,3,1,"","nvrtcVersion"]],"cuda.nvrtc.nvrtcProgram":[[7,2,1,"","getPtr"]],"cuda.nvrtc.nvrtcResult":[[7,0,1,"","NVRTC_ERROR_BUILTIN_OPERATION_FAILURE"],[7,0,1,"","NVRTC_ERROR_COMPILATION"],[7,0,1,"","NVRTC_ERROR_INTERNAL_ERROR"],[7,0,1,"","NVRTC_ERROR_INVALID_INPUT"],[7,0,1,"","NVRTC_ERROR_INVALID_OPTION"],[7,0,1,"","NVRTC_ERROR_INVALID_PROGRAM"],[7,0,1,"","NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID"],[7,0,1,"","NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION"],[7,0,1,"","NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION"],[7,0,1,"","NVRTC_ERROR_OUT_OF_MEMORY"],[7,0,1,"","NVRTC_ERROR_PROGRAM_CREATION_FAILURE"],[7,0,1,"","NVRTC_SUCCESS"]]},objnames:{"0":["py","attribute","Python attribute"],"1":["py","class","Python class"],"2":["py","method","Python method"],"3":["py","function","Python function"]},objtypes:{"0":"py:attribute","1":"py:class","2":"py:method","3":"py:function"},terms:{"0":[3,4,5,6,7,9,10],"02":4,"03":7,"0b":[5,6],"1":[1,3,5,6,7,9,10,13,17],"10":[0,5,7],"100":[5,6],"1000":[5,6],"10000":6,"101":[5,6],"102":[5,6],"1024":[5,6],"103":[5,6],"104":[5,6],"105":[5,6],"106":[5,6],"107":[5,6],"1073741824":5,"1076m":9,"108":[5,6],"1080m":9,"109":[5,6],"11":[0,3,4,5,7,10],"110":[5,6],"11020":5,"11070":[],"11080":5,"111":[5,6],"112":[5,6],"113":[5,6],"114":[5,6],"115":[5,6],"116":[5,6],"117":[5,6],"118":[5,6],"119":[5,6],"12":[5,6,13],"120":[5,6],"121":[5,6],"122":[5,6],"123":5,"124":5,"125":5,"127":6,"128":[5,6],"128b":[5,6],"13":[5,6],"14":[5,6,7],"145":5,"146":5,"147":5,"148":5,"149":5,"15":[5,6],"150":5,"151":5,"152":5,"153":5,"154":5,"155":5,"156":5,"157":5,"158":5,"16":[5,6,11],"16f":[5,6],"16f_arb":[5,6],"16i":[5,6],"16i_ext":[5,6],"16ui":[5,6],"16ui_ext":[5,6],"17":[5,6,7],"176":5,"18":[5,6,12,14],"19":[5,6],"192":5,"193":5,"194":5,"195":5,"196":5,"197":5,"198":5,"199":5,"1d":[5,6],"2":[5,6,7,9,13,16],"20":[5,6],"200":[5,6],"201":[5,6],"202":5,"2021":[11,12],"2022":[13,14,15,16,17,18],"203":5,"2048":[5,6],"205":[5,6],"206":[5,6],"207":[5,6],"208":[5,6],"209":[5,6],"21":[5,6],"210":[5,6],"211":[5,6],"212":[5,6],"213":[5,6],"214":[5,6],"2147483647":[5,6],"215":[5,6],"216":[5,6],"217":[5,6],"218":[5,6,9],"219":[5,6],"22":[5,6,16],"220":[5,6],"221":[5,6],"222":[5,6],"223":[5,6],"224":[5,6],"23":[5,6],"24":[5,6,17],"241":6,"242":6,"25":[5,6],"252":6,"256":[5,6],"26":[5,6],"27":[5,6,18],"28":[5,6],"29":[5,6,16],"2d":[5,6],"3":[5,6,7,9,17],"30":[5,6],"300":[5,6],"301":[5,6],"3010":[5,6],"302":[5,6],"3020":[5,6],"303":[5,6],"304":[5,6],"31":[5,6],"32":[5,6],"32768":9,"32f":[5,6],"32f_arb":[5,6],"32i":[5,6],"32i_ext":[5,6],"32ui":[5,6],"32ui_ext":[5,6],"33":[5,6],"34":[5,6],"35":[5,6],"352\u00b5":9,"36":[5,6],"37":[5,6],"38":[4,5,6],"39":[5,6],"3d":[5,6],"3rd":5,"4":[1,3,5,6,7,9,10],"40":[5,6],"400":[5,6],"401":[5,6],"4020":5,"4096":5,"41":[5,6],"42":[5,6],"43":[5,6],"44":[5,6],"445":[5,6],"45":[5,6],"450":4,"456":4,"46":[5,6],"47":[5,6],"48":[5,6],"49":[5,6],"4x16":5,"5":[3,5,6,7,9,10],"50":[5,6],"500":[5,6],"51":[5,6],"512":[5,6,9],"52":[5,6],"53":[5,6],"54":[5,6],"55":[5,6],"56":[5,6],"57":[5,6],"58":[5,6],"59":[5,6],"6":[3,5,6,7,9,10],"60":[5,6],"600":[5,6],"61":[5,6],"62":[5,6],"63":[5,6],"64":[5,6],"65":[5,6],"66":[5,6],"67":[5,6],"68":[5,6],"69":[5,6],"7":[3,5,6,7,9,10,17],"70":[5,6],"700":[5,6],"701":[5,6],"702":[5,6],"703":[5,6],"704":[5,6],"705":[5,6],"708":[5,6],"709":[5,6],"71":[5,6],"710":[5,6],"711":[5,6],"712":[5,6],"713":[5,6],"714":[5,6],"715":[5,6],"716":[5,6],"717":[5,6],"718":[5,6],"719":[5,6],"72":[5,6],"720":[5,6],"73":[5,6],"74":[5,6],"75":[5,6,9],"76":[5,6],"77":[5,6],"78":[5,6],"79":[5,6],"8":[3,4,5,6,7,10],"80":[4,5,6],"800":[5,6],"801":[5,6],"802":[5,6],"803":[5,6],"804":[5,6],"805":[5,6],"806":[5,6],"807":[5,6],"808":[5,6],"809":[5,6],"81":[5,6],"810":[5,6],"8192":5,"82":[5,6],"83":[5,6],"84":[5,6],"85":[5,6],"86":[5,6],"87":[5,6],"88":[5,6],"89":[5,6],"8i":[5,6],"8i_ext":[5,6],"8ui":[5,6],"8ui_ext":[5,6],"9":[0,5,7],"90":[5,6],"900":[5,6],"901":[5,6],"902":[5,6],"9020":[5,6],"903":[5,6],"904":[5,6],"905":[5,6],"906":[5,6],"907":[5,6],"908":[5,6],"909":[5,6],"91":[5,6],"910":[5,6],"911":[5,6],"912":[5,6],"92":[5,6],"93":[5,6],"94":[5,6],"95":[5,6],"96":[5,6],"97":[5,6],"98":[5,6],"99":[5,6],"999":[5,6],"boolean":5,"break":5,"byte":[5,6,7],"case":[5,6],"char":[5,6,7,9],"class":[5,6,7,13],"const":5,"default":[5,6,7,10,12],"do":[1,2,5,6,7,9],"enum":[5,6],"export":[4,5,6,13],"float":[5,6,7,9],"function":[5,6,7,9,10],"import":[5,6,8,9],"int":[5,6,7,9],"long":[5,6,7,9],"new":[5,6,7,8],"null":[5,6,7],"public":1,"return":[5,6,7,9],"short":[5,7,16],"static":[5,6],"switch":6,"true":[5,6,7,9],"try":[5,6,9],"void":[5,6,9],"while":[5,6],A:[5,6,9,16],As:[5,6,16],At:[2,5,6],Being:1,But:[5,6],By:[5,6,17],For:[1,5,6,7,9],IN:5,If:[2,5,6,7,9],In:[1,5,6,7,8,9,16],It:[5,6,7,9,17],No:[5,6,7],Not:[5,6,10],OR:5,On:[5,6,7],One:9,Such:[5,6],That:[5,9],The:[1,2,4,5,6,7,8,9],Then:4,There:[5,6,9],These:[5,6,7],To:[4,5,6,7,9],With:[8,9],__constant__:7,__global__:9,__int128:7,__threadfence_system:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_memhandle_u:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_resource_u:5,_cuarraymapinfo_v1_cuarraymapinfo_v1_cuarraymapinfo_st_subresource_u:5,_cuda_array_sparse_properties_v1_cuda_array_sparse_properties_v1_cuda_array_sparse_properties_st_tileextent_:5,_cuda_external_memory_handle_desc_v1_cuda_external_memory_handle_desc_v1_cuda_external_memory_handle_desc_st_handle_u:5,_cuda_external_semaphore_handle_desc_v1_cuda_external_semaphore_handle_desc_v1_cuda_external_semaphore_handle_desc_st_handle_u:5,_cuda_external_semaphore_signal_params_v1_cuda_external_semaphore_signal_params_v1_cuda_external_semaphore_signal_params_st_params_:5,_cuda_external_semaphore_wait_params_v1_cuda_external_semaphore_wait_params_v1_cuda_external_semaphore_wait_params_st_params_:5,_cuda_resource_desc_v1_cuda_resource_desc_v1_cuda_resource_desc_st_res_u:5,_cudaarraysparseproperties_tileextent_:6,_cudaeglframe_cudaeglframe_cudaeglframe_st_frame_u:6,_cudaexternalmemoryhandledesc_handle_u:6,_cudaexternalsemaphorehandledesc_handle_u:6,_cudaexternalsemaphoresignalparams_params_:6,_cudaexternalsemaphorewaitparams_params_:6,_cudalaunchattributevalue_cudalaunchattributevalue_cudalaunchattributevalue_clusterdim_:6,_cudalaunchattributevalue_cudalaunchattributevalue_cudalaunchattributevalue_programmaticevent_:6,_cudaresourcedesc_res_u:6,_cueglframe_v1_cueglframe_v1_cueglframe_st_frame_u:5,_cuexecaffinityparam_v1_cuexecaffinityparam_v1_cuexecaffinityparam_st_param_u:5,_culaunchattributevalue_culaunchattributevalue_culaunchattributevalue_union_clusterdim_:5,_culaunchattributevalue_culaunchattributevalue_culaunchattributevalue_union_programmaticevent_:5,_cumemallocationprop_v1_cumemallocationprop_v1_cumemallocationprop_st_allocflags_:5,_ptr:[5,6],_v2:5,abbrevi:[5,6],abgr:[5,6],abi:[5,6,7],abl:[5,6],about:[1,5,6],abov:[4,5,6,9],absent:[5,6],abus:1,acceler:[5,6,8,9],accept:[1,2,5,6,13],acces:[5,6],access:[0,8,9,16],accessdesc:[5,6],accessdesccount:[5,6],accesspolicymaxwindows:6,accesspolicywindow:[5,6],accomplish:[5,6],accord:[5,6],accordingli:[5,6],account:[1,5],accumul:5,achiev:5,acquir:[5,6],across:[5,6],act:1,action:[1,5,6],activ:[4,5,6],actual:[5,6,7],ad:[5,6],adapt:1,add:[5,6,7],addit:[5,6,9],addition:[5,6],addr:5,address:[0,1,7],addressmod:[5,6],advanc:[1,5,6],advers:[5,6],advic:[5,6],advis:[5,6],affect:[5,6],affin:[5,6],after:[5,6,7,9],afterward:5,ag:1,again:[5,6],against:[5,6],aggress:7,agnost:[5,6],ahead:9,ai:8,alia:6,align:[1,5,6],all:[1,4,5,6,7,9,11,12,16,17],allclos:9,alloc:[0,7,9],allocat:[5,6],allocflag:5,alloctyp:[5,6],allow:[5,6,7,8,9,17],along:[5,6,7],alpha:[5,6],alreadi:[5,6],also:[5,6,7,8,9],alter:[5,6],altern:[5,6,7],although:[5,6],alwai:[5,6],among:[5,6,9],amount:[5,6,7],an:[1,2,5,6,7,8,9,13],anaconda:8,analog:9,analyt:[8,9],ani:[1,5,6,7,9],anisotrop:[5,6],anisotropi:[5,6],anistropi:6,annot:7,anoth:[5,6,9],answer:1,anymor:5,api:[3,5,7,8,9,13,14,15,16,17,18],app:[5,6],appear:[1,5,7],appli:[1,5,6],applic:[5,6,8],applicaton:[5,6],appoint:1,appropri:[1,5,6],approprri:6,approx:[5,6],approxim:[5,7],ar:[1,4,5,6,7,8,9,13,16],arbitrari:[5,6],arch:7,architectur:[5,6,7,9],archiv:5,area:[5,6],arg:[5,6,7,9],argb:[5,6],argument:[4,5,6,7,9],arithmet:6,arm:5,around:[5,6],arrai:[5,6,7,8,9],arraydesc:5,arrayindex:[5,6],arriv:5,ascend:7,ascii:[5,6],assembl:7,assert:[5,6,7,9],assert_drv:9,assign:[5,6,7,9],assist:5,associ:[5,6,9],assum:[5,6,7],assumpt:6,astyp:9,async:[5,6],asyncenginecount:6,asynchron:[5,6,9],atom:[5,6],atribut:5,attach:[5,6],attack:1,attempt:[5,6],attent:[1,2],attr:[5,6],attrib:[5,6],attribut:[3,5,6],august:11,auto:6,automat:[5,6,9],avail:[1,5,6,7],availab:5,avoid:[5,6],avui:[5,6],b:[5,6,9],back:[5,6,9],balanc:[5,6],ban:1,bandwidth:[5,6],bank:[5,6],barfoo:5,barfoobaz:5,barrier:[5,6,8],base:[2,5,6,8],base_ptr:[5,6],basic:[5,6,9],batch:5,bayer10:[5,6],bayer12:[5,6],bayer14:[5,6],bayer20:[5,6],bayer:[5,6],bc1:[5,6],bc2:[5,6],bc3:[5,6],bc4:[5,6],bc5:[5,6],bc6h:[5,6],bc7:[5,6],bc:[5,6],bccr:[5,6],becaus:[5,6,7,9],becom:[5,6],been:[5,6,7,9,16],befor:[5,6,9,13],begin:[5,6],begun:[5,6],behav:[5,6],behavior:[1,5,6,13],behind:[5,6],being:[5,6],believ:2,belong:[5,6],below:[5,6,7],benchmark:[],benefit:8,besid:6,best:[1,5,6,8,9],better:6,between:[5,6,7,9],betwen:6,beyond:[5,6],bggr:[5,6],bgr:5,bgra:[5,6],bia:5,bilinear:5,binari:[5,6],binaryvers:6,bind:[4,5,6,8,9,11,12,16],bit:[5,6],bitmask:[5,6],block:[5,6,7,9],blockdim:[6,9],blockdimi:5,blockdimx:5,blockdimz:5,blockidx:9,blocksiz:[5,6],blocksizelimit:5,blocksizetodynamicsmems:5,board:[5,6],bodi:1,border:[5,6],bordercolor:[5,6],both:[1,5,6,8],bound:[5,6],boundari:[5,6],breadth:5,breviti:[5,6,9],bu:[5,6],buffer:[5,6],bufferdesc:[5,6],buffers:[5,6,9],bug:2,build:[3,8,9,10],build_ext:4,built:[6,9],builtin:[5,7],bump:7,bundl:5,burden:[5,6],busi:[5,6],bytecount:5,bytes:[5,6],c:[0,4,5,7,9,16],ca:[5,6],cach:[5,6],cacheconfig:6,cachemodeca:6,calcul:[5,6],call:[5,6,7,9],callback:[5,6],caller:[5,6],can:[4,5,6,7,8,9],canaccessp:[5,6],cancel:7,canmaphostmemori:6,cannot:[5,6],canusehostpointerforregisteredmem:6,cap:5,capabl:[5,6,8,9],capac:[5,6],captur:[5,6],capturestatu:[5,6],capturestatus_out:[5,6],card:6,carveout:[5,6],cast:[5,6],categori:2,caus:[5,6,7],cbrc:[5,6],cccc:[5,6],cd:4,cdp:[5,6],cell:9,certain:[5,6,16],chain:[5,6],chang:[2,5,6,7,9,12,13],channel:[5,6],channeldesc:6,chapter:[5,6],charact:[5,6,7],characterist:1,check:[5,6,9],checkout:4,child:[5,6],childgraph:[5,6],chip:6,choic:5,choos:[5,6],chosen:[5,6],circumst:[1,5,6],cl_context_flag:5,cl_event_flag:5,clamp:[5,6],clarifi:1,clean:[5,6,9],clear:[5,6],cli:9,client:[5,6],clock:[5,6],clockrat:[5,6],clone:[5,6],clonedgraph:6,close:[5,6,9],cluster:[5,6],clusterdim:[5,6],clusters:5,clusterschedulingpolicyprefer:[5,6],co:5,coalesc:[5,6],code:[2,3,5,6,7,8,9,11],coher:[5,6],collaps:[5,6],collect:[5,6],color:[5,6],column:[5,6],com:[1,5,6,16],combin:[5,6],come:[5,6,11,12],comma:[6,7],command:[5,6,9],comment:[1,2],commit:[1,5,6,9],common:[1,5,6,9],commonli:[5,6,9],commun:1,compar:[5,6,9],comparison:5,compat:[4,5,6,8,9],compil:[0,4,5,6,8,9],complaint:1,complet:[5,6,9],compliant:[5,6],compon:[4,5,6],compos:8,composit:[5,6],compress:[5,6],comput:[5,6,8,9],compute_35:7,compute_37:7,compute_50:7,compute_52:7,compute_53:7,compute_60:7,compute_61:7,compute_62:7,compute_70:7,compute_72:7,compute_75:[7,9],compute_80:7,compute_87:7,compute_89:7,compute_90:7,computemod:6,computepreemptionsupport:6,concept:9,concurr:[5,6],concurrentkernel:6,concurrentmanagedaccess:6,conda:[3,12],condit:[5,6],conduct:3,conect:[5,6],confidenti:1,config:[5,6],configur:[5,6,9],conflict:[5,6],conjunct:5,conn:[5,6],connect:[5,6],consecut:[5,6],consid:[1,5,6,7],consist:[5,6],constant:[5,6,7],constantli:[5,6],constitut:5,constrain:[5,6],constraint:[5,6],constrast:6,construct:[1,5,6,9],constsizebyt:6,consum:[5,6],consumpt:[5,6],contact:1,contain:[5,6,7],content:[5,6,7],context:[0,6,9],contigu:[5,6,9],contingu:5,continu:[5,6],contract:[5,6,7],contrari:6,contrast:5,contribut:[1,3,5,6],contributor:1,control:[0,9],conveni:[5,6],convent:[5,6],convers:[5,6],convert:[5,6],cooper:[5,6],cooperativelaunch:6,cooperativemultidevicelaunch:6,coordin:[5,6],copi:[5,6,9],copyparam:5,corner:6,correct:[1,5,6,9],correctli:5,correspon:5,correspond:[5,6,7],corrupt:[5,6],cost:[5,6],could:[1,5,6],count:[5,6],counter:[5,6],counterpart:[5,6],coven:1,coverag:[8,9],cp:4,cpu:[5,6,8,9],crbc:[5,6],creat:[1,4,5,6,7,9],createsharedhandl:[5,6],creation:[5,6,9],criteria:6,critic:1,cross:[5,6],ctk:[4,16,17,18],ctx:5,ctype:9,cu:9,cu_access_property_norm:5,cu_access_property_persist:5,cu_access_property_stream:5,cu_ad_format_bc1_unorm:5,cu_ad_format_bc1_unorm_srgb:5,cu_ad_format_bc2_unorm:5,cu_ad_format_bc2_unorm_srgb:5,cu_ad_format_bc3_unorm:5,cu_ad_format_bc3_unorm_srgb:5,cu_ad_format_bc4_snorm:5,cu_ad_format_bc4_unorm:5,cu_ad_format_bc5_snorm:5,cu_ad_format_bc5_unorm:5,cu_ad_format_bc6h_sf16:5,cu_ad_format_bc6h_uf16:5,cu_ad_format_bc7_unorm:5,cu_ad_format_bc7_unorm_srgb:5,cu_ad_format_float:5,cu_ad_format_half:5,cu_ad_format_nv12:5,cu_ad_format_signed_int16:5,cu_ad_format_signed_int32:5,cu_ad_format_signed_int8:5,cu_ad_format_snorm_int16x1:5,cu_ad_format_snorm_int16x2:5,cu_ad_format_snorm_int16x4:5,cu_ad_format_snorm_int8x1:5,cu_ad_format_snorm_int8x2:5,cu_ad_format_snorm_int8x4:5,cu_ad_format_unorm_int16x1:5,cu_ad_format_unorm_int16x2:5,cu_ad_format_unorm_int16x4:5,cu_ad_format_unorm_int8x1:5,cu_ad_format_unorm_int8x2:5,cu_ad_format_unorm_int8x4:5,cu_ad_format_unsigned_int16:5,cu_ad_format_unsigned_int32:5,cu_ad_format_unsigned_int8:5,cu_array_sparse_properties_single_miptail:5,cu_array_sparse_subresource_type_miptail:5,cu_array_sparse_subresource_type_sparse_level:5,cu_cluster_scheduling_policy_default:5,cu_cluster_scheduling_policy_load_balanc:5,cu_cluster_scheduling_policy_spread:5,cu_computemode_default:5,cu_computemode_exclusive_process:5,cu_computemode_prohibit:5,cu_ctx_blocking_sync:5,cu_ctx_flags_mask:5,cu_ctx_lmem_resize_to_max:5,cu_ctx_map_host:5,cu_ctx_sched_auto:5,cu_ctx_sched_blocking_sync:5,cu_ctx_sched_mask:5,cu_ctx_sched_spin:5,cu_ctx_sched_yield:5,cu_cubemap_face_negative_i:5,cu_cubemap_face_negative_x:5,cu_cubemap_face_negative_z:5,cu_cubemap_face_positive_i:5,cu_cubemap_face_positive_x:5,cu_cubemap_face_positive_z:5,cu_device_attribute_async_engine_count:5,cu_device_attribute_can_flush_remote_writ:5,cu_device_attribute_can_map_host_memori:5,cu_device_attribute_can_tex2d_gath:5,cu_device_attribute_can_use_64_bit_stream_mem_op:5,cu_device_attribute_can_use_64_bit_stream_mem_ops_v2:5,cu_device_attribute_can_use_host_pointer_for_registered_mem:5,cu_device_attribute_can_use_stream_mem_op:5,cu_device_attribute_can_use_stream_wait_value_nor:5,cu_device_attribute_can_use_stream_wait_value_nor_v2:5,cu_device_attribute_clock_r:5,cu_device_attribute_cluster_launch:5,cu_device_attribute_compute_capability_major:5,cu_device_attribute_compute_capability_minor:5,cu_device_attribute_compute_mod:5,cu_device_attribute_compute_preemption_support:5,cu_device_attribute_concurrent_kernel:5,cu_device_attribute_concurrent_managed_access:5,cu_device_attribute_cooperative_launch:5,cu_device_attribute_cooperative_multi_device_launch:5,cu_device_attribute_deferred_mapping_cuda_array_support:5,cu_device_attribute_direct_managed_mem_access_from_host:5,cu_device_attribute_dma_buf_support:5,cu_device_attribute_ecc_en:5,cu_device_attribute_flush_flush_gpu_direct_rdma_opt:5,cu_device_attribute_generic_compression_support:5,cu_device_attribute_global_l1_cache_support:5,cu_device_attribute_global_memory_bus_width:5,cu_device_attribute_gpu_direct_rdma_flush_writes_opt:5,cu_device_attribute_gpu_direct_rdma_support:5,cu_device_attribute_gpu_direct_rdma_with_cuda_vmm_support:5,cu_device_attribute_gpu_direct_rdma_writes_ord:5,cu_device_attribute_gpu_overlap:5,cu_device_attribute_handle_type_posix_file_descriptor_support:5,cu_device_attribute_handle_type_win32_handle_support:5,cu_device_attribute_handle_type_win32_kmt_handle_support:5,cu_device_attribute_host_native_atomic_support:5,cu_device_attribute_host_register_support:5,cu_device_attribute_integr:5,cu_device_attribute_kernel_exec_timeout:5,cu_device_attribute_l2_cache_s:5,cu_device_attribute_local_l1_cache_support:5,cu_device_attribute_managed_memori:5,cu_device_attribute_max:5,cu_device_attribute_max_access_policy_window_s:5,cu_device_attribute_max_block_dim_i:5,cu_device_attribute_max_block_dim_x:5,cu_device_attribute_max_block_dim_z:5,cu_device_attribute_max_blocks_per_multiprocessor:5,cu_device_attribute_max_grid_dim_i:5,cu_device_attribute_max_grid_dim_x:5,cu_device_attribute_max_grid_dim_z:5,cu_device_attribute_max_persisting_l2_cache_s:5,cu_device_attribute_max_pitch:5,cu_device_attribute_max_registers_per_block:5,cu_device_attribute_max_registers_per_multiprocessor:5,cu_device_attribute_max_shared_memory_per_block:5,cu_device_attribute_max_shared_memory_per_block_optin:5,cu_device_attribute_max_shared_memory_per_multiprocessor:5,cu_device_attribute_max_threads_per_block:5,cu_device_attribute_max_threads_per_multiprocessor:5,cu_device_attribute_maximum_surface1d_layered_lay:5,cu_device_attribute_maximum_surface1d_layered_width:5,cu_device_attribute_maximum_surface1d_width:5,cu_device_attribute_maximum_surface2d_height:5,cu_device_attribute_maximum_surface2d_layered_height:5,cu_device_attribute_maximum_surface2d_layered_lay:5,cu_device_attribute_maximum_surface2d_layered_width:5,cu_device_attribute_maximum_surface2d_width:5,cu_device_attribute_maximum_surface3d_depth:5,cu_device_attribute_maximum_surface3d_height:5,cu_device_attribute_maximum_surface3d_width:5,cu_device_attribute_maximum_surfacecubemap_layered_lay:5,cu_device_attribute_maximum_surfacecubemap_layered_width:5,cu_device_attribute_maximum_surfacecubemap_width:5,cu_device_attribute_maximum_texture1d_layered_lay:5,cu_device_attribute_maximum_texture1d_layered_width:5,cu_device_attribute_maximum_texture1d_linear_width:5,cu_device_attribute_maximum_texture1d_mipmapped_width:5,cu_device_attribute_maximum_texture1d_width:5,cu_device_attribute_maximum_texture2d_array_height:5,cu_device_attribute_maximum_texture2d_array_numslic:5,cu_device_attribute_maximum_texture2d_array_width:5,cu_device_attribute_maximum_texture2d_gather_height:5,cu_device_attribute_maximum_texture2d_gather_width:5,cu_device_attribute_maximum_texture2d_height:5,cu_device_attribute_maximum_texture2d_layered_height:5,cu_device_attribute_maximum_texture2d_layered_lay:5,cu_device_attribute_maximum_texture2d_layered_width:5,cu_device_attribute_maximum_texture2d_linear_height:5,cu_device_attribute_maximum_texture2d_linear_pitch:5,cu_device_attribute_maximum_texture2d_linear_width:5,cu_device_attribute_maximum_texture2d_mipmapped_height:5,cu_device_attribute_maximum_texture2d_mipmapped_width:5,cu_device_attribute_maximum_texture2d_width:5,cu_device_attribute_maximum_texture3d_depth:5,cu_device_attribute_maximum_texture3d_depth_altern:5,cu_device_attribute_maximum_texture3d_height:5,cu_device_attribute_maximum_texture3d_height_altern:5,cu_device_attribute_maximum_texture3d_width:5,cu_device_attribute_maximum_texture3d_width_altern:5,cu_device_attribute_maximum_texturecubemap_layered_lay:5,cu_device_attribute_maximum_texturecubemap_layered_width:5,cu_device_attribute_maximum_texturecubemap_width:5,cu_device_attribute_memory_clock_r:5,cu_device_attribute_memory_pools_support:5,cu_device_attribute_mempool_supported_handle_typ:5,cu_device_attribute_multi_gpu_board:5,cu_device_attribute_multi_gpu_board_group_id:5,cu_device_attribute_multiprocessor_count:5,cu_device_attribute_pageable_memory_access:5,cu_device_attribute_pageable_memory_access_uses_host_page_t:5,cu_device_attribute_pci_bus_id:5,cu_device_attribute_pci_device_id:5,cu_device_attribute_pci_domain_id:5,cu_device_attribute_read_only_host_register_support:5,cu_device_attribute_registers_per_block:5,cu_device_attribute_reserved_shared_memory_per_block:5,cu_device_attribute_shared_memory_per_block:5,cu_device_attribute_single_to_double_precision_perf_ratio:5,cu_device_attribute_sparse_cuda_array_support:5,cu_device_attribute_stream_priorities_support:5,cu_device_attribute_surface_align:5,cu_device_attribute_tcc_driv:5,cu_device_attribute_texture_align:5,cu_device_attribute_texture_pitch_align:5,cu_device_attribute_timeline_semaphore_interop_support:5,cu_device_attribute_total_constant_memori:5,cu_device_attribute_unified_address:5,cu_device_attribute_virtual_address_management_support:5,cu_device_attribute_virtual_memory_management_support:5,cu_device_attribute_warp_s:5,cu_device_cpu:5,cu_device_invalid:5,cu_device_p2p_attribute_access_access_support:5,cu_device_p2p_attribute_access_support:5,cu_device_p2p_attribute_cuda_array_access_support:5,cu_device_p2p_attribute_native_atomic_support:5,cu_device_p2p_attribute_performance_rank:5,cu_egl_color_format_a:5,cu_egl_color_format_abgr:5,cu_egl_color_format_argb:5,cu_egl_color_format_ayuv:5,cu_egl_color_format_ayuv_:5,cu_egl_color_format_bayer10_bggr:5,cu_egl_color_format_bayer10_cccc:5,cu_egl_color_format_bayer10_gbrg:5,cu_egl_color_format_bayer10_grbg:5,cu_egl_color_format_bayer10_rggb:5,cu_egl_color_format_bayer12_bccr:5,cu_egl_color_format_bayer12_bggr:5,cu_egl_color_format_bayer12_cbrc:5,cu_egl_color_format_bayer12_cccc:5,cu_egl_color_format_bayer12_crbc:5,cu_egl_color_format_bayer12_gbrg:5,cu_egl_color_format_bayer12_grbg:5,cu_egl_color_format_bayer12_rccb:5,cu_egl_color_format_bayer12_rggb:5,cu_egl_color_format_bayer14_bggr:5,cu_egl_color_format_bayer14_gbrg:5,cu_egl_color_format_bayer14_grbg:5,cu_egl_color_format_bayer14_rggb:5,cu_egl_color_format_bayer20_bggr:5,cu_egl_color_format_bayer20_gbrg:5,cu_egl_color_format_bayer20_grbg:5,cu_egl_color_format_bayer20_rggb:5,cu_egl_color_format_bayer_bccr:5,cu_egl_color_format_bayer_bggr:5,cu_egl_color_format_bayer_cbrc:5,cu_egl_color_format_bayer_crbc:5,cu_egl_color_format_bayer_gbrg:5,cu_egl_color_format_bayer_grbg:5,cu_egl_color_format_bayer_isp_bggr:5,cu_egl_color_format_bayer_isp_gbrg:5,cu_egl_color_format_bayer_isp_grbg:5,cu_egl_color_format_bayer_isp_rggb:5,cu_egl_color_format_bayer_rccb:5,cu_egl_color_format_bayer_rggb:5,cu_egl_color_format_bgr:5,cu_egl_color_format_bgra:5,cu_egl_color_format_i:5,cu_egl_color_format_l:5,cu_egl_color_format_max:5,cu_egl_color_format_r:5,cu_egl_color_format_rg:5,cu_egl_color_format_rgb:5,cu_egl_color_format_rgba:5,cu_egl_color_format_uyvy_422:5,cu_egl_color_format_uyvy_:5,cu_egl_color_format_vyui:5,cu_egl_color_format_vyuy_:5,cu_egl_color_format_y10_709_:5,cu_egl_color_format_y10_:5,cu_egl_color_format_y10v10u10_420_semiplanar:5,cu_egl_color_format_y10v10u10_420_semiplanar_2020:5,cu_egl_color_format_y10v10u10_420_semiplanar_709:5,cu_egl_color_format_y10v10u10_420_semiplanar_709_:5,cu_egl_color_format_y10v10u10_420_semiplanar_:5,cu_egl_color_format_y10v10u10_422_semiplanar:5,cu_egl_color_format_y10v10u10_422_semiplanar_2020:5,cu_egl_color_format_y10v10u10_422_semiplanar_709:5,cu_egl_color_format_y10v10u10_444_semiplanar:5,cu_egl_color_format_y10v10u10_444_semiplanar_709_:5,cu_egl_color_format_y10v10u10_444_semiplanar_:5,cu_egl_color_format_y12_709_:5,cu_egl_color_format_y12_:5,cu_egl_color_format_y12v12u12_420_semiplanar:5,cu_egl_color_format_y12v12u12_420_semiplanar_709_:5,cu_egl_color_format_y12v12u12_420_semiplanar_:5,cu_egl_color_format_y12v12u12_444_semiplanar:5,cu_egl_color_format_y12v12u12_444_semiplanar_709_:5,cu_egl_color_format_y12v12u12_444_semiplanar_:5,cu_egl_color_format_y_709_:5,cu_egl_color_format_y_:5,cu_egl_color_format_yuv420_planar:5,cu_egl_color_format_yuv420_planar_2020:5,cu_egl_color_format_yuv420_planar_709:5,cu_egl_color_format_yuv420_planar_:5,cu_egl_color_format_yuv420_semiplanar:5,cu_egl_color_format_yuv420_semiplanar_2020:5,cu_egl_color_format_yuv420_semiplanar_709:5,cu_egl_color_format_yuv420_semiplanar_:5,cu_egl_color_format_yuv422_planar:5,cu_egl_color_format_yuv422_planar_:5,cu_egl_color_format_yuv422_semiplanar:5,cu_egl_color_format_yuv422_semiplanar_:5,cu_egl_color_format_yuv444_planar:5,cu_egl_color_format_yuv444_planar_:5,cu_egl_color_format_yuv444_semiplanar:5,cu_egl_color_format_yuv444_semiplanar_:5,cu_egl_color_format_yuv:5,cu_egl_color_format_yuv_:5,cu_egl_color_format_yuva:5,cu_egl_color_format_yuva_:5,cu_egl_color_format_yuyv_422:5,cu_egl_color_format_yuyv_:5,cu_egl_color_format_yvu420_planar:5,cu_egl_color_format_yvu420_planar_2020:5,cu_egl_color_format_yvu420_planar_709:5,cu_egl_color_format_yvu420_planar_:5,cu_egl_color_format_yvu420_semiplanar:5,cu_egl_color_format_yvu420_semiplanar_2020:5,cu_egl_color_format_yvu420_semiplanar_709:5,cu_egl_color_format_yvu420_semiplanar_:5,cu_egl_color_format_yvu422_planar:5,cu_egl_color_format_yvu422_planar_:5,cu_egl_color_format_yvu422_semiplanar:5,cu_egl_color_format_yvu422_semiplanar_:5,cu_egl_color_format_yvu444_planar:5,cu_egl_color_format_yvu444_planar_:5,cu_egl_color_format_yvu444_semiplanar:5,cu_egl_color_format_yvu444_semiplanar_:5,cu_egl_color_format_yvyu:5,cu_egl_color_format_yvyu_:5,cu_egl_frame_type_arrai:5,cu_egl_frame_type_pitch:5,cu_egl_resource_location_sysmem:5,cu_egl_resource_location_vidmem:5,cu_event_blocking_sync:5,cu_event_default:5,cu_event_disable_tim:5,cu_event_interprocess:5,cu_event_record_default:5,cu_event_record_extern:5,cu_event_sched_auto:5,cu_event_sched_blocking_sync:5,cu_event_sched_spin:5,cu_event_sched_yield:5,cu_event_wait_default:5,cu_event_wait_extern:5,cu_exec_affinity_type_max:5,cu_exec_affinity_type_sm_count:5,cu_external_memory_handle_type_d3d11_resourc:5,cu_external_memory_handle_type_d3d11_resource_kmt:5,cu_external_memory_handle_type_d3d12_heap:5,cu_external_memory_handle_type_d3d12_resourc:5,cu_external_memory_handle_type_nvscibuf:5,cu_external_memory_handle_type_opaque_fd:5,cu_external_memory_handle_type_opaque_win32:5,cu_external_memory_handle_type_opaque_win32_kmt:5,cu_external_semaphore_handle_type_d3d11_f:5,cu_external_semaphore_handle_type_d3d11_keyed_mutex:5,cu_external_semaphore_handle_type_d3d11_keyed_mutex_kmt:5,cu_external_semaphore_handle_type_d3d12_f:5,cu_external_semaphore_handle_type_nvscisync:5,cu_external_semaphore_handle_type_opaque_fd:5,cu_external_semaphore_handle_type_opaque_win32:5,cu_external_semaphore_handle_type_opaque_win32_kmt:5,cu_external_semaphore_handle_type_timeline_semaphore_fd:5,cu_external_semaphore_handle_type_timeline_semaphore_win32:5,cu_flush_gpu_direct_rdma_writes_option_host:5,cu_flush_gpu_direct_rdma_writes_option_memop:5,cu_flush_gpu_direct_rdma_writes_target_current_ctx:5,cu_flush_gpu_direct_rdma_writes_to_all_devic:5,cu_flush_gpu_direct_rdma_writes_to_own:5,cu_func_attribute_binary_vers:5,cu_func_attribute_cache_mode_ca:5,cu_func_attribute_cluster_scheduling_policy_prefer:5,cu_func_attribute_cluster_size_must_be_set:5,cu_func_attribute_const_size_byt:5,cu_func_attribute_local_size_byt:5,cu_func_attribute_max:5,cu_func_attribute_max_dynamic_shared_size_byt:5,cu_func_attribute_max_threads_per_block:5,cu_func_attribute_non_portable_cluster_size_allow:5,cu_func_attribute_num_reg:5,cu_func_attribute_preferred_shared_memory_carveout:5,cu_func_attribute_ptx_vers:5,cu_func_attribute_required_cluster_depth:5,cu_func_attribute_required_cluster_height:5,cu_func_attribute_required_cluster_width:5,cu_func_attribute_shared_size_byt:5,cu_func_cache_mode_ca:5,cu_func_cache_prefer_equ:5,cu_func_cache_prefer_l1:5,cu_func_cache_prefer_non:5,cu_func_cache_prefer_shar:5,cu_get_proc_address_default:5,cu_get_proc_address_legacy_stream:5,cu_get_proc_address_per_thread_default_stream:5,cu_gl_device_list_al:5,cu_gl_device_list_current_fram:5,cu_gl_device_list_next_fram:5,cu_gpu_direct_rdma_writes_ordering_all_devic:5,cu_gpu_direct_rdma_writes_ordering_non:5,cu_gpu_direct_rdma_writes_ordering_own:5,cu_graph_debug_dot_flags_batch_mem_op_node_param:5,cu_graph_debug_dot_flags_event_node_param:5,cu_graph_debug_dot_flags_ext_semas_signal_node_param:5,cu_graph_debug_dot_flags_ext_semas_wait_node_param:5,cu_graph_debug_dot_flags_handl:5,cu_graph_debug_dot_flags_host_node_param:5,cu_graph_debug_dot_flags_kernel_node_attribut:5,cu_graph_debug_dot_flags_kernel_node_param:5,cu_graph_debug_dot_flags_mem_alloc_node_param:5,cu_graph_debug_dot_flags_mem_free_node_param:5,cu_graph_debug_dot_flags_memcpy_node_param:5,cu_graph_debug_dot_flags_memset_node_param:5,cu_graph_debug_dot_flags_runtime_typ:5,cu_graph_debug_dot_flags_verbos:5,cu_graph_exec_update_error:5,cu_graph_exec_update_error_attributes_chang:5,cu_graph_exec_update_error_function_chang:5,cu_graph_exec_update_error_node_type_chang:5,cu_graph_exec_update_error_not_support:5,cu_graph_exec_update_error_parameters_chang:5,cu_graph_exec_update_error_topology_chang:5,cu_graph_exec_update_error_unsupported_function_chang:5,cu_graph_exec_update_success:5,cu_graph_mem_attr_reserved_mem_curr:5,cu_graph_mem_attr_reserved_mem_high:5,cu_graph_mem_attr_used_mem_curr:5,cu_graph_mem_attr_used_mem_high:5,cu_graph_node_type_batch_mem_op:5,cu_graph_node_type_empti:5,cu_graph_node_type_event_record:5,cu_graph_node_type_ext_semas_sign:5,cu_graph_node_type_ext_semas_wait:5,cu_graph_node_type_graph:5,cu_graph_node_type_host:5,cu_graph_node_type_kernel:5,cu_graph_node_type_mem_alloc:5,cu_graph_node_type_mem_fre:5,cu_graph_node_type_memcpi:5,cu_graph_node_type_memset:5,cu_graph_node_type_wait_ev:5,cu_graph_user_object_mov:5,cu_graphics_map_resource_flags_non:5,cu_graphics_map_resource_flags_read_onli:5,cu_graphics_map_resource_flags_readonli:5,cu_graphics_map_resource_flags_write_discard:5,cu_graphics_map_resource_flags_writediscard:5,cu_graphics_register_flags_non:5,cu_graphics_register_flags_read_onli:5,cu_graphics_register_flags_surface_ldst:5,cu_graphics_register_flags_texture_gath:5,cu_graphics_register_flags_write_discard:5,cu_ipc_handle_s:5,cu_ipc_mem_lazy_enable_peer_access:5,cu_jit_cache_mod:5,cu_jit_cache_option_ca:5,cu_jit_cache_option_cg:5,cu_jit_cache_option_non:5,cu_jit_error_log_buff:5,cu_jit_error_log_buffer_size_byt:5,cu_jit_fallback_strategi:5,cu_jit_fast_compil:5,cu_jit_fma:5,cu_jit_ftz:5,cu_jit_generate_debug_info:5,cu_jit_generate_line_info:5,cu_jit_global_symbol_address:5,cu_jit_global_symbol_count:5,cu_jit_global_symbol_nam:5,cu_jit_info_log_buff:5,cu_jit_info_log_buffer_size_byt:5,cu_jit_input_cubin:5,cu_jit_input_fatbinari:5,cu_jit_input_librari:5,cu_jit_input_nvvm:5,cu_jit_input_object:5,cu_jit_input_ptx:5,cu_jit_log_verbos:5,cu_jit_lto:5,cu_jit_max_regist:5,cu_jit_new_sm3x_opt:5,cu_jit_num_input_typ:5,cu_jit_num_opt:5,cu_jit_optimization_level:5,cu_jit_optimize_unused_device_vari:5,cu_jit_prec_div:5,cu_jit_prec_sqrt:5,cu_jit_referenced_kernel_count:5,cu_jit_referenced_kernel_nam:5,cu_jit_referenced_variable_count:5,cu_jit_referenced_variable_nam:5,cu_jit_target:5,cu_jit_target_from_cucontext:5,cu_jit_threads_per_block:5,cu_jit_wall_tim:5,cu_kernel_node_attribute_access_policy_window:5,cu_kernel_node_attribute_cluster_dimens:5,cu_kernel_node_attribute_cluster_scheduling_policy_prefer:5,cu_kernel_node_attribute_coop:5,cu_kernel_node_attribute_prior:5,cu_launch_attribute_access_policy_window:5,cu_launch_attribute_cluster_dimens:5,cu_launch_attribute_cluster_scheduling_policy_prefer:5,cu_launch_attribute_coop:5,cu_launch_attribute_ignor:5,cu_launch_attribute_prior:5,cu_launch_attribute_programmatic_ev:5,cu_launch_attribute_programmatic_stream_seri:5,cu_launch_attribute_synchronization_polici:5,cu_launch_param_buffer_point:[5,6],cu_launch_param_buffer_pointer_as_int:5,cu_launch_param_buffer_s:[5,6],cu_launch_param_buffer_size_as_int:5,cu_launch_param_end:[5,6],cu_launch_param_end_as_int:5,cu_limit_dev_runtime_pending_launch_count:5,cu_limit_dev_runtime_sync_depth:5,cu_limit_malloc_heap_s:5,cu_limit_max:5,cu_limit_max_l2_fetch_granular:5,cu_limit_persisting_l2_cache_s:5,cu_limit_printf_fifo_s:5,cu_limit_stack_s:5,cu_mem_access_flags_prot_max:5,cu_mem_access_flags_prot_non:5,cu_mem_access_flags_prot_read:5,cu_mem_access_flags_prot_readwrit:5,cu_mem_advise_set_accessed_bi:5,cu_mem_advise_set_preferred_loc:5,cu_mem_advise_set_read_mostli:5,cu_mem_advise_unset_accessed_bi:5,cu_mem_advise_unset_preferred_loc:5,cu_mem_advise_unset_read_mostli:5,cu_mem_alloc_granularity_minimum:5,cu_mem_alloc_granularity_recommend:5,cu_mem_allocation_comp_gener:5,cu_mem_allocation_comp_non:5,cu_mem_allocation_type_invalid:5,cu_mem_allocation_type_max:5,cu_mem_allocation_type_pin:5,cu_mem_attach_glob:5,cu_mem_attach_host:5,cu_mem_attach_singl:5,cu_mem_create_usage_tile_pool:5,cu_mem_handle_type_gener:5,cu_mem_handle_type_max:5,cu_mem_handle_type_non:5,cu_mem_handle_type_posix_file_descriptor:5,cu_mem_handle_type_win32:5,cu_mem_handle_type_win32_kmt:5,cu_mem_location_type_devic:5,cu_mem_location_type_invalid:5,cu_mem_location_type_max:5,cu_mem_operation_type_map:5,cu_mem_operation_type_unmap:5,cu_mem_range_attribute_accessed_bi:5,cu_mem_range_attribute_last_prefetch_loc:5,cu_mem_range_attribute_preferred_loc:5,cu_mem_range_attribute_read_mostli:5,cu_mem_range_handle_type_dma_buf_fd:5,cu_mem_range_handle_type_max:5,cu_memhostalloc_devicemap:5,cu_memhostalloc_port:5,cu_memhostalloc_writecombin:5,cu_memhostergister_read_onli:5,cu_memhostregister_devicemap:5,cu_memhostregister_iomemori:5,cu_memhostregister_port:5,cu_memhostregister_read_onli:5,cu_memorytype_arrai:[5,6],cu_memorytype_devic:[5,6],cu_memorytype_host:5,cu_memorytype_unifi:5,cu_mempool_attr_release_threshold:5,cu_mempool_attr_reserved_mem_curr:5,cu_mempool_attr_reserved_mem_high:5,cu_mempool_attr_reuse_allow_internal_depend:5,cu_mempool_attr_reuse_allow_opportunist:5,cu_mempool_attr_reuse_follow_event_depend:5,cu_mempool_attr_used_mem_curr:5,cu_mempool_attr_used_mem_high:5,cu_module_eager_load:5,cu_module_lazy_load:5,cu_occupancy_default:5,cu_occupancy_disable_caching_overrid:5,cu_param_tr_default:5,cu_pointer_attribute_access_flag:5,cu_pointer_attribute_access_flag_non:5,cu_pointer_attribute_access_flag_read:5,cu_pointer_attribute_access_flag_readwrit:5,cu_pointer_attribute_allowed_handle_typ:5,cu_pointer_attribute_buffer_id:5,cu_pointer_attribute_context:5,cu_pointer_attribute_device_ordin:5,cu_pointer_attribute_device_point:5,cu_pointer_attribute_host_point:5,cu_pointer_attribute_is_gpu_direct_rdma_cap:5,cu_pointer_attribute_is_legacy_cuda_ipc_cap:5,cu_pointer_attribute_is_manag:5,cu_pointer_attribute_map:5,cu_pointer_attribute_mapping_base_addr:5,cu_pointer_attribute_mapping_s:5,cu_pointer_attribute_memory_block_id:5,cu_pointer_attribute_memory_typ:5,cu_pointer_attribute_mempool_handl:5,cu_pointer_attribute_p2p_token:5,cu_pointer_attribute_range_s:5,cu_pointer_attribute_range_start_addr:5,cu_pointer_attribute_sync_memop:5,cu_prefer_binari:5,cu_prefer_ptx:5,cu_res_view_format_float_1x16:5,cu_res_view_format_float_1x32:5,cu_res_view_format_float_2x16:5,cu_res_view_format_float_2x32:5,cu_res_view_format_float_4x16:5,cu_res_view_format_float_4x32:5,cu_res_view_format_non:5,cu_res_view_format_signed_bc4:5,cu_res_view_format_signed_bc5:5,cu_res_view_format_signed_bc6h:5,cu_res_view_format_sint_1x16:5,cu_res_view_format_sint_1x32:5,cu_res_view_format_sint_1x8:5,cu_res_view_format_sint_2x16:5,cu_res_view_format_sint_2x32:5,cu_res_view_format_sint_2x8:5,cu_res_view_format_sint_4x16:5,cu_res_view_format_sint_4x32:5,cu_res_view_format_sint_4x8:5,cu_res_view_format_uint_1x16:5,cu_res_view_format_uint_1x32:5,cu_res_view_format_uint_1x8:5,cu_res_view_format_uint_2x16:5,cu_res_view_format_uint_2x32:5,cu_res_view_format_uint_2x8:5,cu_res_view_format_uint_4x16:5,cu_res_view_format_uint_4x32:5,cu_res_view_format_uint_4x8:5,cu_res_view_format_unsigned_bc1:5,cu_res_view_format_unsigned_bc2:5,cu_res_view_format_unsigned_bc3:5,cu_res_view_format_unsigned_bc4:5,cu_res_view_format_unsigned_bc5:5,cu_res_view_format_unsigned_bc6h:5,cu_res_view_format_unsigned_bc7:5,cu_resource_type_arrai:5,cu_resource_type_linear:5,cu_resource_type_mipmapped_arrai:5,cu_resource_type_pitch2d:5,cu_shared_mem_config_default_bank_s:5,cu_shared_mem_config_eight_byte_bank_s:5,cu_shared_mem_config_four_byte_bank_s:5,cu_sharedmem_carveout_default:5,cu_sharedmem_carveout_max_l1:5,cu_sharedmem_carveout_max_shar:5,cu_stream_add_capture_depend:5,cu_stream_attribute_access_policy_window:5,cu_stream_attribute_synchronization_polici:5,cu_stream_capture_mode_glob:5,cu_stream_capture_mode_relax:5,cu_stream_capture_mode_thread_loc:5,cu_stream_capture_status_act:5,cu_stream_capture_status_invalid:5,cu_stream_capture_status_non:5,cu_stream_default:5,cu_stream_legaci:5,cu_stream_mem_op_barri:5,cu_stream_mem_op_flush_remote_writ:[5,6],cu_stream_mem_op_wait_value_32:5,cu_stream_mem_op_wait_value_64:5,cu_stream_mem_op_write_value_32:5,cu_stream_mem_op_write_value_64:5,cu_stream_memory_barrier_type_gpu:5,cu_stream_memory_barrier_type_si:5,cu_stream_non_block:5,cu_stream_per_thread:5,cu_stream_set_capture_depend:5,cu_stream_wait_value_and:5,cu_stream_wait_value_eq:5,cu_stream_wait_value_flush:[5,6],cu_stream_wait_value_geq:5,cu_stream_wait_value_nor:5,cu_stream_write_value_default:5,cu_stream_write_value_no_memory_barri:5,cu_sync_policy_auto:5,cu_sync_policy_blocking_sync:5,cu_sync_policy_spin:5,cu_sync_policy_yield:5,cu_target_compute_20:5,cu_target_compute_21:5,cu_target_compute_30:5,cu_target_compute_32:5,cu_target_compute_35:5,cu_target_compute_37:5,cu_target_compute_50:5,cu_target_compute_52:5,cu_target_compute_53:5,cu_target_compute_60:5,cu_target_compute_61:5,cu_target_compute_62:5,cu_target_compute_70:5,cu_target_compute_72:5,cu_target_compute_75:5,cu_target_compute_80:5,cu_target_compute_86:5,cu_target_compute_87:5,cu_target_compute_89:5,cu_target_compute_90:5,cu_tr_address_mode_bord:5,cu_tr_address_mode_clamp:5,cu_tr_address_mode_mirror:5,cu_tr_address_mode_wrap:5,cu_tr_filter_mode_linear:5,cu_tr_filter_mode_point:5,cu_trsa_override_format:5,cu_trsf_disable_trilinear_optim:5,cu_trsf_normalized_coordin:5,cu_trsf_read_as_integ:5,cu_trsf_seamless_cubemap:5,cu_trsf_srgb:5,cu_user_object_no_destructor_sync:5,cuaccesspolicywindow:5,cuaccesspolicywindow_st:5,cuaccesspolicywindow_v1:5,cuaccessproperti:[5,6],cuaddress_mod:5,cuarrai:[5,6],cuarray3dcr:[5,6],cuarray3dgetdescriptor:[5,6],cuarray_cubemap_fac:5,cuarray_format:5,cuarraycr:[5,6],cuarraydestroi:[5,6],cuarraygetdescriptor:[5,6],cuarraygetmemoryrequir:5,cuarraygetplan:[5,6],cuarraygetsparseproperti:5,cuarraymapinfo:5,cuarraymapinfo_st:5,cuarraymapinfo_v1:5,cuarraysparsesubresourcetyp:5,cuarraysparsesubresourcetype_enum:5,cube:[5,6],cubemap:[5,6],cubin:[5,7],cubinout:5,cubinsizeret:7,cuclusterschedulingpolici:5,cucomputemod:5,cucontext:[5,6],cuctx_flag:5,cuctxcreat:[5,9],cuctxcreate_v3:5,cuctxdestroi:[5,6,9],cuctxdisablepeeraccess:[5,6],cuctxenablepeeraccess:[5,6],cuctxgetapivers:[5,6],cuctxgetcacheconfig:[5,6],cuctxgetcurr:[5,6],cuctxgetdevic:5,cuctxgetexecaffin:5,cuctxgetflag:[5,6],cuctxgetlimit:[5,6],cuctxgetsharedmemconfig:[5,6],cuctxgetstreampriorityrang:[5,6],cuctxpopcurr:5,cuctxpushcurr:5,cuctxresetpersistingl2cach:5,cuctxsetcacheconfig:[5,6],cuctxsetcurr:[5,6],cuctxsetlimit:[5,6],cuctxsetsharedmemconfig:[5,6],cuctxsynchron:[5,6],cuda:[1,2,4,7,10],cuda_api_per_thread_default_stream:[5,6],cuda_array3d_2darrai:5,cuda_array3d_color_attach:5,cuda_array3d_cubemap:5,cuda_array3d_deferred_map:5,cuda_array3d_depth_textur:5,cuda_array3d_descriptor:5,cuda_array3d_descriptor_st:5,cuda_array3d_descriptor_v2:5,cuda_array3d_lay:5,cuda_array3d_spars:5,cuda_array3d_surface_ldst:5,cuda_array3d_texture_gath:5,cuda_array_descriptor:5,cuda_array_descriptor_st:5,cuda_array_descriptor_v2:5,cuda_array_memory_requir:5,cuda_array_memory_requirements_st:5,cuda_array_memory_requirements_v1:5,cuda_array_sparse_properti:5,cuda_array_sparse_properties_st:5,cuda_array_sparse_properties_v1:5,cuda_batch_mem_op_node_param:5,cuda_batch_mem_op_node_params_st:5,cuda_cooperative_launch_multi_device_no_post_launch_sync:5,cuda_cooperative_launch_multi_device_no_pre_launch_sync:5,cuda_egl:[5,6],cuda_egl_infinite_timeout:5,cuda_egl_max_plan:6,cuda_error_already_acquir:5,cuda_error_already_map:5,cuda_error_array_is_map:5,cuda_error_assert:5,cuda_error_captured_ev:5,cuda_error_compat_not_supported_on_devic:5,cuda_error_context_already_curr:5,cuda_error_context_already_in_us:5,cuda_error_context_is_destroi:5,cuda_error_cooperative_launch_too_larg:5,cuda_error_deiniti:5,cuda_error_device_not_licens:5,cuda_error_device_unavail:5,cuda_error_ecc_uncorrect:5,cuda_error_external_devic:5,cuda_error_file_not_found:5,cuda_error_graph_exec_update_failur:5,cuda_error_hardware_stack_error:5,cuda_error_host_memory_already_regist:5,cuda_error_host_memory_not_regist:5,cuda_error_illegal_address:5,cuda_error_illegal_instruct:5,cuda_error_illegal_st:5,cuda_error_invalid_address_spac:5,cuda_error_invalid_cluster_s:5,cuda_error_invalid_context:5,cuda_error_invalid_devic:5,cuda_error_invalid_graphics_context:5,cuda_error_invalid_handl:5,cuda_error_invalid_imag:5,cuda_error_invalid_pc:5,cuda_error_invalid_ptx:5,cuda_error_invalid_sourc:5,cuda_error_invalid_valu:[5,6],cuda_error_jit_compilation_dis:5,cuda_error_jit_compiler_not_found:5,cuda_error_launch_fail:5,cuda_error_launch_incompatible_textur:5,cuda_error_launch_out_of_resourc:5,cuda_error_launch_timeout:5,cuda_error_map_fail:5,cuda_error_misaligned_address:5,cuda_error_mps_client_termin:5,cuda_error_mps_connection_fail:5,cuda_error_mps_max_clients_reach:5,cuda_error_mps_max_connections_reach:5,cuda_error_mps_rpc_failur:5,cuda_error_mps_server_not_readi:5,cuda_error_no_binary_for_gpu:5,cuda_error_no_devic:5,cuda_error_not_found:5,cuda_error_not_initi:[5,6],cuda_error_not_map:5,cuda_error_not_mapped_as_arrai:5,cuda_error_not_mapped_as_point:5,cuda_error_not_permit:5,cuda_error_not_readi:5,cuda_error_not_support:5,cuda_error_nvlink_uncorrect:5,cuda_error_operating_system:5,cuda_error_out_of_memori:[5,6],cuda_error_peer_access_already_en:5,cuda_error_peer_access_not_en:5,cuda_error_peer_access_unsupport:5,cuda_error_primary_context_act:5,cuda_error_profiler_already_start:5,cuda_error_profiler_already_stop:5,cuda_error_profiler_dis:5,cuda_error_profiler_not_initi:5,cuda_error_shared_object_init_fail:5,cuda_error_shared_object_symbol_not_found:5,cuda_error_stream_capture_implicit:5,cuda_error_stream_capture_invalid:5,cuda_error_stream_capture_isol:5,cuda_error_stream_capture_merg:5,cuda_error_stream_capture_unjoin:5,cuda_error_stream_capture_unmatch:5,cuda_error_stream_capture_unsupport:5,cuda_error_stream_capture_wrong_thread:5,cuda_error_stub_librari:5,cuda_error_system_driver_mismatch:5,cuda_error_system_not_readi:5,cuda_error_timeout:5,cuda_error_too_many_p:5,cuda_error_unknown:5,cuda_error_unmap_fail:5,cuda_error_unsupported_exec_affin:5,cuda_error_unsupported_limit:5,cuda_error_unsupported_ptx_vers:5,cuda_ext_sem_signal_node_param:5,cuda_ext_sem_signal_node_params_st:5,cuda_ext_sem_signal_node_params_v1:5,cuda_ext_sem_wait_node_param:5,cuda_ext_sem_wait_node_params_st:5,cuda_ext_sem_wait_node_params_v1:5,cuda_external_memory_buffer_desc:5,cuda_external_memory_buffer_desc_st:5,cuda_external_memory_buffer_desc_v1:5,cuda_external_memory_ded:5,cuda_external_memory_handle_desc:5,cuda_external_memory_handle_desc_st:5,cuda_external_memory_handle_desc_v1:5,cuda_external_memory_mipmapped_array_desc:5,cuda_external_memory_mipmapped_array_desc_st:5,cuda_external_memory_mipmapped_array_desc_v1:5,cuda_external_semaphore_handle_desc:5,cuda_external_semaphore_handle_desc_st:5,cuda_external_semaphore_handle_desc_v1:5,cuda_external_semaphore_param:5,cuda_external_semaphore_signal_param:5,cuda_external_semaphore_signal_params_st:5,cuda_external_semaphore_signal_params_v1:5,cuda_external_semaphore_signal_skip_nvscibuf_memsync:5,cuda_external_semaphore_wait_param:5,cuda_external_semaphore_wait_params_st:5,cuda_external_semaphore_wait_params_v1:5,cuda_external_semaphore_wait_skip_nvscibuf_memsync:5,cuda_graph_instantiate_flag_auto_free_on_launch:5,cuda_graph_instantiate_flag_use_node_prior:5,cuda_hom:[4,16,17],cuda_host_node_param:5,cuda_host_node_params_st:5,cuda_host_node_params_v1:5,cuda_ipc_handle_s:6,cuda_kernel_node_param:5,cuda_kernel_node_params_st:5,cuda_kernel_node_params_v1:5,cuda_launch_param:5,cuda_launch_params_st:5,cuda_launch_params_v1:5,cuda_managed_force_device_alloc:[5,6],cuda_mem_alloc_node_param:5,cuda_mem_alloc_node_params_st:5,cuda_memcpy2d:5,cuda_memcpy2d_st:5,cuda_memcpy2d_v2:5,cuda_memcpy3d:5,cuda_memcpy3d_p:5,cuda_memcpy3d_peer_st:5,cuda_memcpy3d_peer_v1:5,cuda_memcpy3d_st:5,cuda_memcpy3d_v2:5,cuda_memset_node_param:5,cuda_memset_node_params_st:5,cuda_memset_node_params_v1:5,cuda_module_load:5,cuda_nvscisync_attr_sign:5,cuda_nvscisync_attr_wait:5,cuda_pointer_attribute_access_flag:5,cuda_pointer_attribute_p2p_token:5,cuda_pointer_attribute_p2p_tokens_st:5,cuda_pointer_attribute_p2p_tokens_v1:5,cuda_python_cuda_per_thread_default_stream:13,cuda_resource_desc:5,cuda_resource_desc_st:5,cuda_resource_desc_v1:5,cuda_resource_view_desc:5,cuda_resource_view_desc_st:5,cuda_resource_view_desc_v1:5,cuda_runtim:16,cuda_success:[5,6,9],cuda_texture_desc:5,cuda_texture_desc_st:5,cuda_texture_desc_v1:5,cuda_vers:5,cuda_visible_devic:[5,6],cudaaccesspolicywindow:6,cudaaccessproperti:6,cudaaccesspropertynorm:6,cudaaccesspropertypersist:6,cudaaccesspropertystream:6,cudaaddressmodebord:6,cudaaddressmodeclamp:6,cudaaddressmodemirror:6,cudaaddressmodewrap:6,cudaarrai:[5,6],cudaarray_const_t:6,cudaarray_t:6,cudaarraycolorattach:6,cudaarraycubemap:6,cudaarraydefault:6,cudaarraydeferredmap:6,cudaarraygetinfo:[5,6],cudaarraygetmemoryrequir:6,cudaarraygetplan:6,cudaarraygetsparseproperti:6,cudaarraylay:6,cudaarraymemoryrequir:6,cudaarrayspars:6,cudaarraysparseproperti:6,cudaarraysparsepropertiessinglemiptail:6,cudaarraysurfaceloadstor:6,cudaarraytexturegath:6,cudabindsurfacetoarrai:[11,12],cudabindtextur:[11,12],cudabindtexture2d:[11,12],cudabindtexturetoarrai:[11,12],cudabindtexturetomipmappedarrai:[11,12],cudaboundarymodeclamp:6,cudaboundarymodetrap:6,cudaboundarymodezero:6,cudacc_rtc_int128:7,cudacgscop:6,cudacgscopegrid:6,cudacgscopeinvalid:6,cudacgscopemultigrid:6,cudachannelformatdesc:6,cudachannelformatkind:6,cudachannelformatkindfloat:6,cudachannelformatkindnon:6,cudachannelformatkindnv12:6,cudachannelformatkindsign:6,cudachannelformatkindsignedblockcompressed4:6,cudachannelformatkindsignedblockcompressed5:6,cudachannelformatkindsignedblockcompressed6h:6,cudachannelformatkindsignednormalized16x1:6,cudachannelformatkindsignednormalized16x2:6,cudachannelformatkindsignednormalized16x4:6,cudachannelformatkindsignednormalized8x1:6,cudachannelformatkindsignednormalized8x2:6,cudachannelformatkindsignednormalized8x4:6,cudachannelformatkindunsign:6,cudachannelformatkindunsignedblockcompressed1:6,cudachannelformatkindunsignedblockcompressed1srgb:6,cudachannelformatkindunsignedblockcompressed2:6,cudachannelformatkindunsignedblockcompressed2srgb:6,cudachannelformatkindunsignedblockcompressed3:6,cudachannelformatkindunsignedblockcompressed3srgb:6,cudachannelformatkindunsignedblockcompressed4:6,cudachannelformatkindunsignedblockcompressed5:6,cudachannelformatkindunsignedblockcompressed6h:6,cudachannelformatkindunsignedblockcompressed7:6,cudachannelformatkindunsignedblockcompressed7srgb:6,cudachannelformatkindunsignednormalized16x1:6,cudachannelformatkindunsignednormalized16x2:6,cudachannelformatkindunsignednormalized16x4:6,cudachannelformatkindunsignednormalized8x1:6,cudachannelformatkindunsignednormalized8x2:6,cudachannelformatkindunsignednormalized8x4:6,cudachoosedevic:6,cudaclusterschedulingpolici:[5,6],cudaclusterschedulingpolicydefault:6,cudaclusterschedulingpolicyloadbalanc:6,cudaclusterschedulingpolicyspread:6,cudacomputemod:6,cudacomputemodedefault:6,cudacomputemodeexclus:6,cudacomputemodeexclusiveprocess:6,cudacomputemodeprohibit:6,cudaconfigurecal:6,cudacooperativelaunchmultidevicenopostsync:6,cudacooperativelaunchmultidevicenopresync:6,cudacpudeviceid:6,cudacreatechanneldesc:6,cudacreatesurfaceobject:[5,6],cudacreatetextureobject:[5,6],cudacreatetextureobject_v2:6,cudacsv:6,cudactxcanaccessp:6,cudactxdisablepeeraccess:6,cudactxenablepeeraccess:6,cudactxresetpersistingl2cach:6,cudad3d10setdirect3ddevic:6,cudad3d11setdirect3ddevic:6,cudad3d9setdirect3ddevic:6,cudadestroyexternalmemori:6,cudadestroyexternalsemaphor:6,cudadestroysurfaceobject:[5,6],cudadestroytextureobject:[5,6],cudadevattrasyncenginecount:6,cudadevattrcanflushremotewrit:6,cudadevattrcanmaphostmemori:6,cudadevattrcanusehostpointerforregisteredmem:6,cudadevattrclockr:6,cudadevattrclusterlaunch:6,cudadevattrcomputecapabilitymajor:6,cudadevattrcomputecapabilityminor:6,cudadevattrcomputemod:6,cudadevattrcomputepreemptionsupport:6,cudadevattrconcurrentkernel:6,cudadevattrconcurrentmanagedaccess:6,cudadevattrcooperativelaunch:6,cudadevattrcooperativemultidevicelaunch:6,cudadevattrdeferredmappingcudaarraysupport:6,cudadevattrdirectmanagedmemaccessfromhost:6,cudadevattreccen:6,cudadevattrgloball1cachesupport:6,cudadevattrglobalmemorybuswidth:6,cudadevattrgpudirectrdmaflushwritesopt:6,cudadevattrgpudirectrdmasupport:6,cudadevattrgpudirectrdmawritesord:6,cudadevattrgpuoverlap:6,cudadevattrhostnativeatomicsupport:6,cudadevattrhostregisterreadonlysupport:6,cudadevattrhostregistersupport:6,cudadevattrintegr:6,cudadevattrismultigpuboard:6,cudadevattrkernelexectimeout:6,cudadevattrl2caches:6,cudadevattrlocall1cachesupport:6,cudadevattrmanagedmemori:6,cudadevattrmax:6,cudadevattrmaxaccesspolicywindows:6,cudadevattrmaxblockdimi:6,cudadevattrmaxblockdimx:6,cudadevattrmaxblockdimz:6,cudadevattrmaxblockspermultiprocessor:6,cudadevattrmaxgriddimi:6,cudadevattrmaxgriddimx:6,cudadevattrmaxgriddimz:6,cudadevattrmaxpersistingl2caches:6,cudadevattrmaxpitch:6,cudadevattrmaxregistersperblock:6,cudadevattrmaxregisterspermultiprocessor:6,cudadevattrmaxsharedmemoryperblock:6,cudadevattrmaxsharedmemoryperblockoptin:6,cudadevattrmaxsharedmemorypermultiprocessor:6,cudadevattrmaxsurface1dlayeredlay:6,cudadevattrmaxsurface1dlayeredwidth:6,cudadevattrmaxsurface1dwidth:6,cudadevattrmaxsurface2dheight:6,cudadevattrmaxsurface2dlayeredheight:6,cudadevattrmaxsurface2dlayeredlay:6,cudadevattrmaxsurface2dlayeredwidth:6,cudadevattrmaxsurface2dwidth:6,cudadevattrmaxsurface3ddepth:6,cudadevattrmaxsurface3dheight:6,cudadevattrmaxsurface3dwidth:6,cudadevattrmaxsurfacecubemaplayeredlay:6,cudadevattrmaxsurfacecubemaplayeredwidth:6,cudadevattrmaxsurfacecubemapwidth:6,cudadevattrmaxtexture1dlayeredlay:6,cudadevattrmaxtexture1dlayeredwidth:6,cudadevattrmaxtexture1dlinearwidth:6,cudadevattrmaxtexture1dmipmappedwidth:6,cudadevattrmaxtexture1dwidth:6,cudadevattrmaxtexture2dgatherheight:6,cudadevattrmaxtexture2dgatherwidth:6,cudadevattrmaxtexture2dheight:6,cudadevattrmaxtexture2dlayeredheight:6,cudadevattrmaxtexture2dlayeredlay:6,cudadevattrmaxtexture2dlayeredwidth:6,cudadevattrmaxtexture2dlinearheight:6,cudadevattrmaxtexture2dlinearpitch:6,cudadevattrmaxtexture2dlinearwidth:6,cudadevattrmaxtexture2dmipmappedheight:6,cudadevattrmaxtexture2dmipmappedwidth:6,cudadevattrmaxtexture2dwidth:6,cudadevattrmaxtexture3ddepth:6,cudadevattrmaxtexture3ddepthalt:6,cudadevattrmaxtexture3dheight:6,cudadevattrmaxtexture3dheightalt:6,cudadevattrmaxtexture3dwidth:6,cudadevattrmaxtexture3dwidthalt:6,cudadevattrmaxtexturecubemaplayeredlay:6,cudadevattrmaxtexturecubemaplayeredwidth:6,cudadevattrmaxtexturecubemapwidth:6,cudadevattrmaxthreadsperblock:6,cudadevattrmaxthreadspermultiprocessor:6,cudadevattrmaxtimelinesemaphoreinteropsupport:6,cudadevattrmemoryclockr:6,cudadevattrmemorypoolssupport:6,cudadevattrmemorypoolsupportedhandletyp:6,cudadevattrmultigpuboardgroupid:6,cudadevattrmultiprocessorcount:6,cudadevattrpageablememoryaccess:6,cudadevattrpageablememoryaccessuseshostpaget:6,cudadevattrpcibusid:6,cudadevattrpcideviceid:6,cudadevattrpcidomainid:6,cudadevattrreserved92:6,cudadevattrreserved93:6,cudadevattrreserved94:6,cudadevattrreservedsharedmemoryperblock:6,cudadevattrsingletodoubleprecisionperfratio:6,cudadevattrsparsecudaarraysupport:6,cudadevattrstreamprioritiessupport:6,cudadevattrsurfacealign:6,cudadevattrtccdriv:6,cudadevattrtexturealign:6,cudadevattrtexturepitchalign:6,cudadevattrtimelinesemaphoreinteropsupport:6,cudadevattrtotalconstantmemori:6,cudadevattrunifiedaddress:6,cudadevattrwarps:6,cudadeviceattr:6,cudadeviceattrreadonlyhostregistersupport:6,cudadeviceblockingsync:6,cudadevicecanaccessp:[5,6],cudadevicecount:[5,6],cudadevicedisablepeeraccess:[5,6],cudadeviceenablepeeraccess:[5,6],cudadeviceflushgpudirectrdmawrit:6,cudadevicegetattribut:[5,6],cudadevicegetbypcibusid:[5,6],cudadevicegetcacheconfig:[5,6],cudadevicegetdefaultmempool:6,cudadevicegetgraphmemattribut:6,cudadevicegetlimit:[5,6],cudadevicegetmempool:6,cudadevicegetnvscisyncattribut:6,cudadevicegetp2pattribut:[5,6],cudadevicegetpcibusid:[5,6],cudadevicegetsharedmemconfig:[5,6],cudadevicegetstreampriorityrang:[5,6],cudadevicegettexture1dlinearmaxwidth:[5,6],cudadevicegraphmemtrim:6,cudadevicelmemresizetomax:6,cudadevicemaphost:6,cudadevicemask:6,cudadevicep2pattr:6,cudadeviceprop:6,cudadevicereset:[5,6],cudadevicescheduleauto:6,cudadevicescheduleblockingsync:6,cudadeviceschedulemask:6,cudadeviceschedulespin:6,cudadevicescheduleyield:6,cudadevicesetcacheconfig:[5,6],cudadevicesetgraphmemattribut:6,cudadevicesetlimit:[5,6],cudadevicesetmempool:6,cudadevicesetsharedmemconfig:[5,6],cudadevicesynchron:[5,6],cudadevp2pattraccesssupport:6,cudadevp2pattrcudaarrayaccesssupport:6,cudadevp2pattrnativeatomicsupport:6,cudadevp2pattrperformancerank:6,cudadrivergetvers:[5,6],cudaeglcolorformat:6,cudaeglcolorformata:6,cudaeglcolorformatabgr:6,cudaeglcolorformatargb:6,cudaeglcolorformatayuv:6,cudaeglcolorformatayuv_:6,cudaeglcolorformatbayer10bggr:6,cudaeglcolorformatbayer10cccc:6,cudaeglcolorformatbayer10gbrg:6,cudaeglcolorformatbayer10grbg:6,cudaeglcolorformatbayer10rggb:6,cudaeglcolorformatbayer12bccr:6,cudaeglcolorformatbayer12bggr:6,cudaeglcolorformatbayer12cbrc:6,cudaeglcolorformatbayer12cccc:6,cudaeglcolorformatbayer12crbc:6,cudaeglcolorformatbayer12gbrg:6,cudaeglcolorformatbayer12grbg:6,cudaeglcolorformatbayer12rccb:6,cudaeglcolorformatbayer12rggb:6,cudaeglcolorformatbayer14bggr:6,cudaeglcolorformatbayer14gbrg:6,cudaeglcolorformatbayer14grbg:6,cudaeglcolorformatbayer14rggb:6,cudaeglcolorformatbayer20bggr:6,cudaeglcolorformatbayer20gbrg:6,cudaeglcolorformatbayer20grbg:6,cudaeglcolorformatbayer20rggb:6,cudaeglcolorformatbayerbccr:6,cudaeglcolorformatbayerbggr:6,cudaeglcolorformatbayercbrc:6,cudaeglcolorformatbayercrbc:6,cudaeglcolorformatbayergbrg:6,cudaeglcolorformatbayergrbg:6,cudaeglcolorformatbayerispbggr:6,cudaeglcolorformatbayerispgbrg:6,cudaeglcolorformatbayerispgrbg:6,cudaeglcolorformatbayerisprggb:6,cudaeglcolorformatbayerrccb:6,cudaeglcolorformatbayerrggb:6,cudaeglcolorformatbgra:6,cudaeglcolorformati:6,cudaeglcolorformatl:6,cudaeglcolorformatr:6,cudaeglcolorformatrg:6,cudaeglcolorformatrgba:6,cudaeglcolorformatuyvy422:6,cudaeglcolorformatuyvy_:6,cudaeglcolorformatvyui:6,cudaeglcolorformatvyuy_:6,cudaeglcolorformaty10_709_:6,cudaeglcolorformaty10_:6,cudaeglcolorformaty10v10u10_420semiplanar:6,cudaeglcolorformaty10v10u10_420semiplanar_2020:6,cudaeglcolorformaty10v10u10_420semiplanar_709:6,cudaeglcolorformaty10v10u10_420semiplanar_709_:6,cudaeglcolorformaty10v10u10_420semiplanar_:6,cudaeglcolorformaty10v10u10_422semiplanar:6,cudaeglcolorformaty10v10u10_422semiplanar_2020:6,cudaeglcolorformaty10v10u10_422semiplanar_709:6,cudaeglcolorformaty10v10u10_444semiplanar:6,cudaeglcolorformaty10v10u10_444semiplanar_709_:6,cudaeglcolorformaty10v10u10_444semiplanar_:6,cudaeglcolorformaty12_709_:6,cudaeglcolorformaty12_:6,cudaeglcolorformaty12v12u12_420semiplanar:6,cudaeglcolorformaty12v12u12_420semiplanar_709_:6,cudaeglcolorformaty12v12u12_420semiplanar_:6,cudaeglcolorformaty12v12u12_444semiplanar:6,cudaeglcolorformaty12v12u12_444semiplanar_709_:6,cudaeglcolorformaty12v12u12_444semiplanar_:6,cudaeglcolorformaty_709_:6,cudaeglcolorformaty_:6,cudaeglcolorformatyuv420planar:6,cudaeglcolorformatyuv420planar_2020:6,cudaeglcolorformatyuv420planar_709:6,cudaeglcolorformatyuv420planar_:6,cudaeglcolorformatyuv420semiplanar:6,cudaeglcolorformatyuv420semiplanar_2020:6,cudaeglcolorformatyuv420semiplanar_709:6,cudaeglcolorformatyuv420semiplanar_:6,cudaeglcolorformatyuv422planar:6,cudaeglcolorformatyuv422planar_:6,cudaeglcolorformatyuv422semiplanar:6,cudaeglcolorformatyuv422semiplanar_:6,cudaeglcolorformatyuv444planar:6,cudaeglcolorformatyuv444planar_:6,cudaeglcolorformatyuv444semiplanar:6,cudaeglcolorformatyuv444semiplanar_:6,cudaeglcolorformatyuva:6,cudaeglcolorformatyuva_:6,cudaeglcolorformatyuyv422:6,cudaeglcolorformatyuyv_:6,cudaeglcolorformatyvu420planar:6,cudaeglcolorformatyvu420planar_2020:6,cudaeglcolorformatyvu420planar_709:6,cudaeglcolorformatyvu420planar_:6,cudaeglcolorformatyvu420semiplanar:6,cudaeglcolorformatyvu420semiplanar_2020:6,cudaeglcolorformatyvu420semiplanar_709:6,cudaeglcolorformatyvu420semiplanar_:6,cudaeglcolorformatyvu422planar:6,cudaeglcolorformatyvu422planar_:6,cudaeglcolorformatyvu422semiplanar:6,cudaeglcolorformatyvu422semiplanar_:6,cudaeglcolorformatyvu444planar:6,cudaeglcolorformatyvu444planar_:6,cudaeglcolorformatyvu444semiplanar:6,cudaeglcolorformatyvu444semiplanar_:6,cudaeglcolorformatyvyu:6,cudaeglcolorformatyvyu_:6,cudaeglfram:6,cudaeglframe_st:6,cudaeglframetyp:6,cudaeglframetypearrai:6,cudaeglframetypepitch:6,cudaeglplanedesc:6,cudaeglplanedesc_st:6,cudaeglresourcelocationflag:6,cudaeglresourcelocationsysmem:6,cudaeglresourcelocationvidmem:6,cudaeglstreamconnect:6,cudaeglstreamconsumeracquirefram:[5,6,12],cudaeglstreamconsumerconnect:[5,6,12],cudaeglstreamconsumerconnectwithflag:[5,6,12],cudaeglstreamconsumerdisconnect:[5,6,12],cudaeglstreamconsumerreleasefram:[5,6,12],cudaeglstreamproducerconnect:[5,6,12],cudaeglstreamproducerdisconnect:[5,6,12],cudaeglstreamproducerpresentfram:[5,6,12],cudaeglstreamproducerreturnfram:[5,6,12],cudaenabledefault:6,cudaenablelegacystream:6,cudaenablepeeraccess:6,cudaenableperthreaddefaultstream:6,cudaerror:6,cudaerror_t:[6,13],cudaerroraddressofconst:6,cudaerroralreadyacquir:6,cudaerroralreadymap:6,cudaerrorapifailurebas:6,cudaerrorarrayismap:6,cudaerrorassert:6,cudaerrorcallrequiresnewerdriv:6,cudaerrorcapturedev:6,cudaerrorcompatnotsupportedondevic:6,cudaerrorcontextisdestroi:6,cudaerrorcooperativelaunchtoolarg:6,cudaerrorcudartunload:6,cudaerrordevicealreadyinus:6,cudaerrordevicenotlicens:6,cudaerrordevicesunavail:6,cudaerrordeviceuniniti:6,cudaerrorduplicatesurfacenam:6,cudaerrorduplicatetexturenam:6,cudaerrorduplicatevariablenam:6,cudaerroreccuncorrect:6,cudaerrorexternaldevic:6,cudaerrorfilenotfound:6,cudaerrorgraphexecupdatefailur:6,cudaerrorhardwarestackerror:6,cudaerrorhostmemoryalreadyregist:6,cudaerrorhostmemorynotregist:6,cudaerrorillegaladdress:6,cudaerrorillegalinstruct:6,cudaerrorillegalst:6,cudaerrorincompatibledrivercontext:6,cudaerrorinitializationerror:6,cudaerrorinsufficientdriv:6,cudaerrorinvalidaddressspac:6,cudaerrorinvalidchanneldescriptor:6,cudaerrorinvalidclusters:6,cudaerrorinvalidconfigur:6,cudaerrorinvalidcontext:6,cudaerrorinvaliddevic:6,cudaerrorinvaliddevicefunct:6,cudaerrorinvaliddevicepoint:6,cudaerrorinvalidfilterset:6,cudaerrorinvalidgraphicscontext:6,cudaerrorinvalidhandl:6,cudaerrorinvalidhostpoint:6,cudaerrorinvalidkernelimag:6,cudaerrorinvalidmemcpydirect:6,cudaerrorinvalidnormset:6,cudaerrorinvalidpc:6,cudaerrorinvalidpitchvalu:6,cudaerrorinvalidptx:6,cudaerrorinvalidresourcehandl:6,cudaerrorinvalidsourc:6,cudaerrorinvalidsurfac:6,cudaerrorinvalidsymbol:6,cudaerrorinvalidtextur:6,cudaerrorinvalidtexturebind:6,cudaerrorinvalidvalu:6,cudaerrorjitcompilationdis:6,cudaerrorjitcompilernotfound:6,cudaerrorlaunchfailur:6,cudaerrorlaunchfilescopedsurf:6,cudaerrorlaunchfilescopedtex:6,cudaerrorlaunchincompatibletextur:6,cudaerrorlaunchmaxdepthexceed:6,cudaerrorlaunchoutofresourc:6,cudaerrorlaunchpendingcountexceed:[5,6],cudaerrorlaunchtimeout:6,cudaerrormapbufferobjectfail:6,cudaerrormemoryalloc:6,cudaerrormemoryvaluetoolarg:6,cudaerrormisalignedaddress:6,cudaerrormissingconfigur:6,cudaerrormixeddeviceexecut:6,cudaerrormpsclienttermin:6,cudaerrormpsconnectionfail:6,cudaerrormpsmaxclientsreach:6,cudaerrormpsmaxconnectionsreach:6,cudaerrormpsrpcfailur:6,cudaerrormpsservernotreadi:6,cudaerrornodevic:6,cudaerrornokernelimagefordevic:6,cudaerrornotmap:6,cudaerrornotmappedasarrai:6,cudaerrornotmappedaspoint:6,cudaerrornotpermit:6,cudaerrornotreadi:6,cudaerrornotsupport:6,cudaerrornotyetimpl:6,cudaerrornvlinkuncorrect:6,cudaerroroperatingsystem:6,cudaerroroutofmemori:6,cudaerrorpeeraccessalreadyen:6,cudaerrorpeeraccessnoten:6,cudaerrorpeeraccessunsupport:6,cudaerrorpriorlaunchfailur:6,cudaerrorprofileralreadystart:6,cudaerrorprofileralreadystop:6,cudaerrorprofilerdis:6,cudaerrorprofilernotiniti:6,cudaerrorsetonactiveprocess:6,cudaerrorsharedobjectinitfail:6,cudaerrorsharedobjectsymbolnotfound:6,cudaerrorsoftwarevaliditynotestablish:6,cudaerrorstartupfailur:6,cudaerrorstreamcaptureimplicit:6,cudaerrorstreamcaptureinvalid:6,cudaerrorstreamcaptureisol:6,cudaerrorstreamcapturemerg:6,cudaerrorstreamcaptureunjoin:6,cudaerrorstreamcaptureunmatch:6,cudaerrorstreamcaptureunsupport:6,cudaerrorstreamcapturewrongthread:6,cudaerrorstublibrari:6,cudaerrorsymbolnotfound:6,cudaerrorsyncdepthexceed:[5,6],cudaerrorsynchronizationerror:6,cudaerrorsystemdrivermismatch:6,cudaerrorsystemnotreadi:6,cudaerrortexturefetchfail:6,cudaerrortexturenotbound:6,cudaerrortimeout:6,cudaerrortoomanyp:6,cudaerrorunknown:6,cudaerrorunmapbufferobjectfail:6,cudaerrorunsupportedexecaffin:6,cudaerrorunsupportedlimit:6,cudaerrorunsupportedptxvers:6,cudaerrorvalu:6,cudaevent_t:[5,6],cudaeventblockingsync:6,cudaeventcr:[5,6],cudaeventcreatefromeglsync:[6,12],cudaeventcreatewithflag:[5,6],cudaeventdefault:6,cudaeventdestroi:[5,6],cudaeventdisabletim:6,cudaeventelapsedtim:[5,6],cudaeventinterprocess:6,cudaeventqueri:[5,6],cudaeventrecord:[5,6],cudaeventrecorddefault:6,cudaeventrecordextern:6,cudaeventrecordwithflag:6,cudaeventsynchron:[5,6],cudaeventwaitdefault:6,cudaeventwaitextern:6,cudaext:6,cudaexternalmemory_t:6,cudaexternalmemorybufferdesc:6,cudaexternalmemoryded:6,cudaexternalmemorygetmappedbuff:6,cudaexternalmemorygetmappedmipmappedarrai:6,cudaexternalmemoryhandledesc:6,cudaexternalmemoryhandletyp:6,cudaexternalmemoryhandletyped3d11resourc:6,cudaexternalmemoryhandletyped3d11resourcekmt:6,cudaexternalmemoryhandletyped3d12heap:6,cudaexternalmemoryhandletyped3d12resourc:6,cudaexternalmemoryhandletypenvscibuf:6,cudaexternalmemoryhandletypeopaquefd:6,cudaexternalmemoryhandletypeopaquewin32:6,cudaexternalmemoryhandletypeopaquewin32kmt:6,cudaexternalmemorymipmappedarraydesc:6,cudaexternalsemaphore_t:6,cudaexternalsemaphorehandledesc:6,cudaexternalsemaphorehandletyp:6,cudaexternalsemaphorehandletyped3d11f:6,cudaexternalsemaphorehandletyped3d12f:6,cudaexternalsemaphorehandletypekeyedmutex:6,cudaexternalsemaphorehandletypekeyedmutexkmt:6,cudaexternalsemaphorehandletypenvscisync:6,cudaexternalsemaphorehandletypeopaquefd:6,cudaexternalsemaphorehandletypeopaquewin32:6,cudaexternalsemaphorehandletypeopaquewin32kmt:6,cudaexternalsemaphorehandletypetimelinesemaphorefd:6,cudaexternalsemaphorehandletypetimelinesemaphorewin32:6,cudaexternalsemaphoresignalnodeparam:6,cudaexternalsemaphoresignalparam:6,cudaexternalsemaphoresignalskipnvscibufmemsync:6,cudaexternalsemaphorewaitnodeparam:6,cudaexternalsemaphorewaitparam:6,cudaexternalsemaphorewaitskipnvscibufmemsync:6,cudafiltermodelinear:6,cudafiltermodepoint:6,cudaflushgpudirectrdmawrit:6,cudaflushgpudirectrdmawritesopt:6,cudaflushgpudirectrdmawritesoptionhost:6,cudaflushgpudirectrdmawritesoptionmemop:6,cudaflushgpudirectrdmawritesscop:6,cudaflushgpudirectrdmawritestarget:6,cudaflushgpudirectrdmawritestargetcurrentdevic:6,cudaflushgpudirectrdmawritestoalldevic:6,cudaflushgpudirectrdmawritestoown:6,cudaformatmodeauto:6,cudaformatmodeforc:6,cudafre:[5,6],cudafreearrai:[5,6],cudafreeasync:6,cudafreehost:[5,6],cudafreemipmappedarrai:[5,6],cudafuncattribut:6,cudafuncattributeclusterdimmustbeset:6,cudafuncattributeclusterschedulingpolicyprefer:6,cudafuncattributemax:6,cudafuncattributemaxdynamicsharedmemorys:6,cudafuncattributenonportableclustersizeallow:6,cudafuncattributepreferredsharedmemorycarveout:6,cudafuncattributerequiredclusterdepth:6,cudafuncattributerequiredclusterheight:6,cudafuncattributerequiredclusterwidth:6,cudafunccach:6,cudafunccachepreferequ:6,cudafunccachepreferl1:6,cudafunccacheprefernon:6,cudafunccacheprefershar:6,cudafuncgetattribut:[5,6],cudafuncsetattribut:[5,6],cudafuncsetcacheconfig:[5,6],cudafuncsetsharedmemconfig:[5,6],cudafunction_t:6,cudagetarrayplan:5,cudagetchanneldesc:6,cudagetdevic:[5,6],cudagetdevicecount:[5,6],cudagetdeviceflag:[5,6],cudagetdeviceproperti:[5,6],cudagetdriverentrypoint:[5,6],cudagetdriverentrypointflag:6,cudageterrornam:[5,6],cudageterrorstr:[5,6],cudagetfuncbysymbol:[11,12,13,14,15,16,17,18],cudagetlasterror:[5,6],cudagetmipmappedarraylevel:[5,6],cudagetsurfaceobjectresourcedesc:[5,6],cudagetsurfacerefer:[5,11,12],cudagetsymboladdress:[5,11,12,13,14,15,16,17,18],cudagetsymbols:[5,11,12,13,14,15,16,17,18],cudagettexturealignmentoffset:[6,11,12],cudagettextureobjectresourcedesc:[5,6],cudagettextureobjectresourceviewdesc:[5,6],cudagettextureobjecttexturedesc:[5,6],cudagettextureobjecttexturedesc_v2:6,cudagettexturerefer:[5,11,12],cudagldevicelist:6,cudagldevicelistal:6,cudagldevicelistcurrentfram:6,cudagldevicelistnextfram:6,cudaglgetdevic:[5,6,12],cudaglmapbufferobject:12,cudaglmapbufferobjectasync:12,cudaglregisterbufferobject:12,cudaglsetbufferobjectmapflag:12,cudaglsetgldevic:[6,12],cudaglunmapbufferobject:12,cudaglunmapbufferobjectasync:12,cudaglunregisterbufferobject:12,cudagpudirectrdmawritesord:6,cudagpudirectrdmawritesorderingalldevic:6,cudagpudirectrdmawritesorderingnon:6,cudagpudirectrdmawritesorderingown:6,cudagraph_t:[5,6],cudagraphaddchildgraphnod:6,cudagraphadddepend:6,cudagraphaddemptynod:6,cudagraphaddeventrecordnod:6,cudagraphaddeventwaitnod:6,cudagraphaddexternalsemaphoressignalnod:6,cudagraphaddexternalsemaphoreswaitnod:6,cudagraphaddhostnod:6,cudagraphaddkernelnod:6,cudagraphaddmemallocnod:6,cudagraphaddmemcpynod:6,cudagraphaddmemcpynode1d:6,cudagraphaddmemcpynodefromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphaddmemcpynodetosymbol:[6,11,12,13,14,15,16,17,18],cudagraphaddmemfreenod:6,cudagraphaddmemsetnod:6,cudagraphchildgraphnodegetgraph:6,cudagraphclon:6,cudagraphcr:6,cudagraphdebugdotflag:6,cudagraphdebugdotflagseventnodeparam:6,cudagraphdebugdotflagsextsemassignalnodeparam:6,cudagraphdebugdotflagsextsemaswaitnodeparam:6,cudagraphdebugdotflagshandl:6,cudagraphdebugdotflagshostnodeparam:6,cudagraphdebugdotflagskernelnodeattribut:6,cudagraphdebugdotflagskernelnodeparam:6,cudagraphdebugdotflagsmemcpynodeparam:6,cudagraphdebugdotflagsmemsetnodeparam:6,cudagraphdebugdotflagsverbos:6,cudagraphdebugdotprint:6,cudagraphdestroi:6,cudagraphdestroynod:6,cudagrapheventrecordnodegetev:6,cudagrapheventrecordnodesetev:6,cudagrapheventwaitnodegetev:6,cudagrapheventwaitnodesetev:6,cudagraphexec_t:[5,6],cudagraphexecchildgraphnodesetparam:6,cudagraphexecdestroi:6,cudagraphexeceventrecordnodesetev:6,cudagraphexeceventwaitnodesetev:6,cudagraphexecexternalsemaphoressignalnodesetparam:6,cudagraphexecexternalsemaphoreswaitnodesetparam:6,cudagraphexechostnodesetparam:6,cudagraphexeckernelnodesetparam:6,cudagraphexecmemcpynodesetparam:6,cudagraphexecmemcpynodesetparams1d:6,cudagraphexecmemcpynodesetparamsfromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphexecmemcpynodesetparamstosymbol:[6,11,12,13,14,15,16,17,18],cudagraphexecmemsetnodesetparam:6,cudagraphexecupd:6,cudagraphexecupdateerror:6,cudagraphexecupdateerrorattributeschang:6,cudagraphexecupdateerrorfunctionchang:6,cudagraphexecupdateerrornodetypechang:6,cudagraphexecupdateerrornotsupport:6,cudagraphexecupdateerrorparameterschang:6,cudagraphexecupdateerrortopologychang:6,cudagraphexecupdateerrorunsupportedfunctionchang:6,cudagraphexecupdateresult:6,cudagraphexecupdatesuccess:6,cudagraphexternalsemaphoressignalnodegetparam:6,cudagraphexternalsemaphoressignalnodesetparam:6,cudagraphexternalsemaphoreswaitnodegetparam:6,cudagraphexternalsemaphoreswaitnodesetparam:6,cudagraphgetedg:6,cudagraphgetnod:6,cudagraphgetrootnod:6,cudagraphhostnodegetparam:6,cudagraphhostnodesetparam:6,cudagraphicscubefac:6,cudagraphicscubefacenegativei:6,cudagraphicscubefacenegativex:6,cudagraphicscubefacenegativez:6,cudagraphicscubefacepositivei:6,cudagraphicscubefacepositivex:6,cudagraphicscubefacepositivez:6,cudagraphicsd3d10registerresourc:6,cudagraphicsd3d11registerresourc:6,cudagraphicsd3d9registerresourc:6,cudagraphicseglregisterimag:[5,6,12],cudagraphicsglregisterbuff:[5,6,12],cudagraphicsglregisterimag:[5,6,12],cudagraphicsmapflag:6,cudagraphicsmapflagsnon:6,cudagraphicsmapflagsreadonli:6,cudagraphicsmapflagswritediscard:6,cudagraphicsmapresourc:[5,6],cudagraphicsregisterflag:6,cudagraphicsregisterflagsnon:6,cudagraphicsregisterflagsreadonli:6,cudagraphicsregisterflagssurfaceloadstor:6,cudagraphicsregisterflagstexturegath:6,cudagraphicsregisterflagswritediscard:6,cudagraphicsresourc:6,cudagraphicsresource_t:6,cudagraphicsresourcegetmappedeglfram:[6,12],cudagraphicsresourcegetmappedmipmappedarrai:[5,6],cudagraphicsresourcegetmappedpoint:6,cudagraphicsresourcesetmapflag:[5,6],cudagraphicssubresourcegetmappedarrai:[5,6],cudagraphicsunmapresourc:[5,6],cudagraphicsunregisterresourc:[5,6],cudagraphicsvdpauregisteroutputsurfac:[5,6,12],cudagraphicsvdpauregistervideosurfac:[5,6,12],cudagraphinstanti:6,cudagraphinstantiateflag:6,cudagraphinstantiateflagautofreeonlaunch:6,cudagraphinstantiateflagusenodeprior:6,cudagraphinstantiatewithflag:6,cudagraphkernelnodecopyattribut:6,cudagraphkernelnodegetattribut:6,cudagraphkernelnodegetparam:6,cudagraphkernelnodesetattribut:6,cudagraphkernelnodesetparam:6,cudagraphlaunch:6,cudagraphmemallocnodegetparam:6,cudagraphmemattributetyp:6,cudagraphmemattrreservedmemcurr:6,cudagraphmemattrreservedmemhigh:6,cudagraphmemattrusedmemcurr:6,cudagraphmemattrusedmemhigh:6,cudagraphmemcpynodegetparam:6,cudagraphmemcpynodesetparam:6,cudagraphmemcpynodesetparams1d:6,cudagraphmemcpynodesetparamsfromsymbol:[6,11,12,13,14,15,16,17,18],cudagraphmemcpynodesetparamstosymbol:[6,11,12,13,14,15,16,17,18],cudagraphmemfreenodegetparam:6,cudagraphmemsetnodegetparam:6,cudagraphmemsetnodesetparam:6,cudagraphnode_t:[5,6],cudagraphnodefindinclon:6,cudagraphnodegetdepend:6,cudagraphnodegetdependentnod:6,cudagraphnodegeten:6,cudagraphnodegettyp:6,cudagraphnodeseten:6,cudagraphnodetyp:6,cudagraphnodetypecount:6,cudagraphnodetypeempti:6,cudagraphnodetypeeventrecord:6,cudagraphnodetypeextsemaphoresign:6,cudagraphnodetypeextsemaphorewait:6,cudagraphnodetypegraph:6,cudagraphnodetypehost:6,cudagraphnodetypekernel:6,cudagraphnodetypememalloc:6,cudagraphnodetypememcpi:6,cudagraphnodetypememfre:6,cudagraphnodetypememset:6,cudagraphnodetypewaitev:6,cudagraphreleaseuserobject:6,cudagraphremovedepend:6,cudagraphretainuserobject:6,cudagraphupload:6,cudagraphuserobjectmov:6,cudahostalloc:[5,6],cudahostallocdefault:6,cudahostallocmap:6,cudahostallocport:6,cudahostallocwritecombin:6,cudahostfn_t:6,cudahostgetdevicepoint:[5,6],cudahostgetflag:[5,6],cudahostnodeparam:6,cudahostregist:[5,6],cudahostregisterdefault:6,cudahostregisteriomemori:6,cudahostregistermap:6,cudahostregisterport:6,cudahostregisterreadonli:6,cudahostunregist:[5,6],cudaimportexternalmemori:6,cudaimportexternalsemaphor:6,cudainvaliddeviceid:6,cudaipcclosememhandl:[5,6],cudaipceventhandl:6,cudaipceventhandle_st:6,cudaipceventhandle_t:6,cudaipcgeteventhandl:[5,6],cudaipcgetmemhandl:[5,6],cudaipcmemhandl:6,cudaipcmemhandle_st:6,cudaipcmemhandle_t:6,cudaipcmemlazyenablepeeraccess:6,cudaipcopeneventhandl:[5,6],cudaipcopenmemhandl:[5,6],cudakernelnodeattributeclusterdimens:6,cudakernelnodeattributeclusterschedulingpolicyprefer:6,cudakernelnodeattrid:6,cudakernelnodeattrvalu:6,cudakernelnodeparam:6,cudakeyvaluepair:6,cudalaunchattribut:6,cudalaunchattribute_st:6,cudalaunchattributeaccesspolicywindow:6,cudalaunchattributeclusterdimens:6,cudalaunchattributeclusterschedulingpolicyprefer:6,cudalaunchattributecoop:6,cudalaunchattributeid:6,cudalaunchattributeignor:6,cudalaunchattributeprior:6,cudalaunchattributeprogrammaticev:6,cudalaunchattributeprogrammaticstreamseri:6,cudalaunchattributesynchronizationpolici:6,cudalaunchattributevalu:6,cudalaunchcooperativekernel:[5,6,11,12,13,14,15,16,17,18],cudalaunchcooperativekernelmultidevic:[5,6,11,12,13,14,15,16,17,18],cudalaunchhostfunc:6,cudalaunchkernel:[5,6,11,12,13,14,15,16,17,18],cudalaunchkernelex:5,cudalimit:6,cudalimitdevruntimependinglaunchcount:6,cudalimitdevruntimesyncdepth:6,cudalimitmallocheaps:6,cudalimitmaxl2fetchgranular:6,cudalimitpersistingl2caches:6,cudalimitprintffifos:6,cudalimitstacks:6,cudamalloc3d:6,cudamalloc3darrai:[5,6],cudamalloc:[5,6],cudamallocarrai:[5,6],cudamallocasync:6,cudamallocfrompoolasync:6,cudamallochost:[5,6],cudamallocmanag:[5,6],cudamallocmipmappedarrai:[5,6],cudamallocpitch:[5,6],cudamaphost:6,cudamemaccessdesc:6,cudamemaccessflag:6,cudamemaccessflagsprotnon:6,cudamemaccessflagsprotread:6,cudamemaccessflagsprotreadwrit:6,cudamemadvicereadmostli:6,cudamemadvicesetaccessedbi:6,cudamemadviceunsetreadmostli:6,cudamemadvis:[5,6],cudamemadvisesetaccessedbi:6,cudamemadvisesetpreferredloc:6,cudamemadvisesetreadmostli:6,cudamemadviseunsetaccessedbi:6,cudamemadviseunsetpreferredloc:6,cudamemadviseunsetreadmostli:6,cudamemallocationhandletyp:6,cudamemallocationtyp:6,cudamemallocationtypeinvalid:6,cudamemallocationtypemax:6,cudamemallocationtypepin:6,cudamemallocnodeparam:6,cudamemattachglob:6,cudamemattachhost:6,cudamemattachsingl:6,cudamemcpi:[5,6],cudamemcpy2d:[5,6],cudamemcpy2darraytoarrai:6,cudamemcpy2dasync:[5,6],cudamemcpy2dfromarrai:[5,6],cudamemcpy2dfromarrayasync:[5,6],cudamemcpy2dtoarrai:[5,6],cudamemcpy2dtoarrayasync:[5,6],cudamemcpy3d:[5,6],cudamemcpy3dasync:[5,6],cudamemcpy3dp:[5,6],cudamemcpy3dparm:6,cudamemcpy3dpeerasync:[5,6],cudamemcpy3dpeerparm:6,cudamemcpyarraytoarrai:5,cudamemcpyasync:[5,6],cudamemcpydefault:6,cudamemcpydevicetodevic:6,cudamemcpydevicetohost:6,cudamemcpyfromarrai:5,cudamemcpyfromarrayasync:5,cudamemcpyfromsymbol:[5,6,11,12,13,14,15,16,17,18],cudamemcpyfromsymbolasync:[5,6,11,12,13,14,15,16,17,18],cudamemcpyhosttodevic:6,cudamemcpyhosttohost:6,cudamemcpykind:6,cudamemcpyp:[5,6],cudamemcpypeerasync:[5,6],cudamemcpytoarrai:5,cudamemcpytoarrayasync:5,cudamemcpytosymbol:[5,6,11,12,13,14,15,16,17,18],cudamemcpytosymbolasync:[5,6,11,12,13,14,15,16,17,18],cudamemfre:6,cudamemfreeasync:6,cudamemgetinfo:[5,6],cudamemhandletypenon:6,cudamemhandletypeposixfiledescriptor:6,cudamemhandletypewin32:6,cudamemhandletypewin32kmt:6,cudamemloc:6,cudamemlocationtyp:6,cudamemlocationtypedevic:6,cudamemlocationtypeinvalid:6,cudamemoryadvis:6,cudamemorytyp:6,cudamemorytypedevic:6,cudamemorytypehost:6,cudamemorytypemanag:6,cudamemorytypeunregist:6,cudamempool:6,cudamempool_t:[5,6],cudamempoolattr:6,cudamempoolattrreleasethreshold:6,cudamempoolattrreservedmemcurr:6,cudamempoolattrreservedmemhigh:6,cudamempoolattrusedmemcurr:6,cudamempoolattrusedmemhigh:6,cudamempoolcr:6,cudamempooldestroi:6,cudamempoolexportpoint:6,cudamempoolexporttoshareablehandl:6,cudamempoolgetaccess:6,cudamempoolgetattribut:6,cudamempoolimportfromshareablehandl:6,cudamempoolimportpoint:6,cudamempoolprop:6,cudamempoolptrexportdata:6,cudamempoolreuseallowinternaldepend:6,cudamempoolreuseallowopportunist:6,cudamempoolreusefolloweventdepend:6,cudamempoolsetaccess:6,cudamempoolsetattribut:6,cudamempooltrimto:6,cudamemprefetchasync:[5,6],cudamemrangeattribut:6,cudamemrangeattributeaccessedbi:6,cudamemrangeattributelastprefetchloc:6,cudamemrangeattributepreferredloc:6,cudamemrangeattributereadmostli:6,cudamemrangegetattribut:[5,6],cudamemset2d:[5,6],cudamemset2dasync:[5,6],cudamemset3d:6,cudamemset3dasync:6,cudamemset:[5,6],cudamemsetasync:[5,6],cudamemsetparam:6,cudamipmappedarray_const_t:6,cudamipmappedarray_t:6,cudamipmappedarraygetlevel:6,cudamipmappedarraygetmemoryrequir:6,cudamipmappedarraygetsparseproperti:6,cudanvscisyncattrsign:6,cudanvscisyncattrwait:6,cudaoccupancyavailabledynamicsmemperblock:6,cudaoccupancydefault:6,cudaoccupancydisablecachingoverrid:6,cudaoccupancymaxactiveblockspermultiprocessor:[5,6],cudaoccupancymaxactiveblockspermultiprocessorwithflag:[5,6],cudaoccupancymaxactiveclust:5,cudaoccupancymaxpotentialblocks:[5,6],cudaoccupancymaxpotentialblocksizevariablesmem:6,cudaoccupancymaxpotentialblocksizevariablesmemwithflag:6,cudaoccupancymaxpotentialblocksizewithflag:[5,6],cudaoutputmode_t:6,cudapeekatlasterror:6,cudapeeraccessdefault:6,cudapitchedptr:6,cudapo:6,cudapointerattribut:6,cudapointergetattribut:[5,6],cudaprofil:16,cudaprofileriniti:[6,12],cudaprofilerstart:[5,6,12],cudaprofilerstop:[5,6,12],cudareadmodeelementtyp:6,cudareadmodenormalizedfloat:6,cudaresourcedesc:6,cudaresourcetyp:6,cudaresourcetypearrai:6,cudaresourcetypelinear:6,cudaresourcetypemipmappedarrai:6,cudaresourcetypepitch2d:6,cudaresourceviewdesc:6,cudaresourceviewformat:6,cudaresviewformatfloat1:6,cudaresviewformatfloat2:6,cudaresviewformatfloat4:6,cudaresviewformathalf1:6,cudaresviewformathalf2:6,cudaresviewformathalf4:6,cudaresviewformatnon:6,cudaresviewformatsignedblockcompressed4:6,cudaresviewformatsignedblockcompressed5:6,cudaresviewformatsignedblockcompressed6h:6,cudaresviewformatsignedchar1:6,cudaresviewformatsignedchar2:6,cudaresviewformatsignedchar4:6,cudaresviewformatsignedint1:6,cudaresviewformatsignedint2:6,cudaresviewformatsignedint4:6,cudaresviewformatsignedshort1:6,cudaresviewformatsignedshort2:6,cudaresviewformatsignedshort4:6,cudaresviewformatunsignedblockcompressed1:6,cudaresviewformatunsignedblockcompressed2:6,cudaresviewformatunsignedblockcompressed3:6,cudaresviewformatunsignedblockcompressed4:6,cudaresviewformatunsignedblockcompressed5:6,cudaresviewformatunsignedblockcompressed6h:6,cudaresviewformatunsignedblockcompressed7:6,cudaresviewformatunsignedchar1:6,cudaresviewformatunsignedchar2:6,cudaresviewformatunsignedchar4:6,cudaresviewformatunsignedint1:6,cudaresviewformatunsignedint2:6,cudaresviewformatunsignedint4:6,cudaresviewformatunsignedshort1:6,cudaresviewformatunsignedshort2:6,cudaresviewformatunsignedshort4:6,cudart:[0,3,13],cudaruntimegetvers:[5,6],cudasetdevic:[5,6],cudasetdeviceflag:[5,6],cudasetdoublefordevic:6,cudasetdoubleforhost:6,cudasetvaliddevic:[6,11,12,13,14,15,16,17,18],cudasharedcarveout:6,cudasharedmembanksizedefault:6,cudasharedmembanksizeeightbyt:6,cudasharedmembanksizefourbyt:6,cudasharedmemcarveoutdefault:6,cudasharedmemcarveoutmaxl1:6,cudasharedmemcarveoutmaxshar:6,cudasharedmemconfig:6,cudasignalexternalsemaphoresasync:6,cudastream_t:[5,6,13],cudastreamaddcallback:[5,6],cudastreamaddcapturedepend:6,cudastreamattachmemasync:[5,6],cudastreamattrid:6,cudastreamattrvalu:6,cudastreambegincaptur:6,cudastreamcallback_t:6,cudastreamcapturemod:6,cudastreamcapturemodeglob:6,cudastreamcapturemoderelax:6,cudastreamcapturemodethreadloc:6,cudastreamcapturestatu:6,cudastreamcapturestatusact:6,cudastreamcapturestatusinvalid:6,cudastreamcapturestatusnon:6,cudastreamcopyattribut:6,cudastreamcr:[5,6],cudastreamcreatewithflag:[5,6],cudastreamcreatewithprior:[5,6],cudastreamdefault:6,cudastreamdestroi:[5,6],cudastreamendcaptur:6,cudastreamgetattribut:6,cudastreamgetcaptureinfo:6,cudastreamgetcaptureinfo_v2:6,cudastreamgetflag:[5,6],cudastreamgetprior:[5,6],cudastreamiscaptur:6,cudastreamlegaci:[5,6],cudastreamnonblock:[6,13],cudastreamperthread:[5,6],cudastreamqueri:[5,6,13],cudastreamsetattribut:6,cudastreamsetcapturedepend:6,cudastreamsynchron:[5,6],cudastreamupdatecapturedepend:6,cudastreamupdatecapturedependenciesflag:6,cudastreamwaitev:[5,6],cudasuccess:[6,13],cudasurfaceboundarymod:6,cudasurfaceformatmod:6,cudasurfaceobject_t:6,cudasurfacetype1d:6,cudasurfacetype1dlay:6,cudasurfacetype2d:6,cudasurfacetype2dlay:6,cudasurfacetype3d:6,cudasurfacetypecubemap:6,cudasurfacetypecubemaplay:6,cudasynchronizationpolici:6,cudasyncpolicyauto:6,cudasyncpolicyblockingsync:6,cudasyncpolicyspin:6,cudasyncpolicyyield:6,cudatextureaddressmod:6,cudatexturedesc:6,cudatexturedesc_v2:6,cudatexturefiltermod:6,cudatextureobject_t:6,cudatexturereadmod:6,cudatexturetype1d:6,cudatexturetype1dlay:6,cudatexturetype2d:6,cudatexturetype2dlay:6,cudatexturetype3d:6,cudatexturetypecubemap:6,cudatexturetypecubemaplay:6,cudathreadexchangestreamcapturemod:6,cudathreadgetcacheconfig:6,cudathreadsetcacheconfig:6,cudatriggerprogrammaticlaunchcomplet:5,cudatypedef:[5,6],cudaunbindtextur:[11,12],cudauserobject_t:6,cudauserobjectcr:6,cudauserobjectflag:6,cudauserobjectnodestructorsync:6,cudauserobjectreleas:6,cudauserobjectretain:6,cudauserobjectretainflag:6,cudauuid_t:6,cudavdpaugetdevic:[5,6,12],cudavdpausetvdpaudevic:[6,12,13,14,15,16,17,18],cudavers:5,cudawaitexternalsemaphoresasync:6,cudawglgetdevic:12,cudestroyexternalmemori:5,cudestroyexternalsemaphor:5,cudevic:[5,9],cudevice_attribut:5,cudevice_p2pattribut:5,cudevice_v1:5,cudevicecanaccessp:[5,6],cudeviceget:[5,9],cudevicegetattribut:[5,6],cudevicegetbypcibusid:[5,6],cudevicegetcount:[5,6],cudevicegetdefaultmempool:[5,6],cudevicegetexecaffinitysupport:5,cudevicegetgraphmemattribut:5,cudevicegetluid:5,cudevicegetmaxtexture1dlinear:6,cudevicegetmempool:[5,6],cudevicegetnam:[5,6],cudevicegetnvscisyncattribut:5,cudevicegetp2pattribut:[5,6],cudevicegetpcibusid:[5,6],cudevicegettexture1dlinearmaxwidth:[5,6],cudevicegetuuid:5,cudevicegetuuid_v2:5,cudevicegraphmemtrim:5,cudeviceprimaryctxgetst:[5,6],cudeviceprimaryctxreleas:5,cudeviceprimaryctxreset:5,cudeviceprimaryctxretain:5,cudeviceprimaryctxsetflag:[5,6],cudeviceptr:[5,9],cudeviceptr_v2:5,cudevicesetdefaultmempool:6,cudevicesetgraphmemattribut:5,cudevicesetmempool:[5,6],cudevicetotalmem:5,cudevprop:5,cudevprop_st:5,cudevprop_v1:5,cudrivergetvers:[5,6],cudriverprocaddress_flag:5,cueglcolorformat:5,cueglfram:5,cueglframe_st:5,cueglframe_v1:5,cueglframetyp:5,cueglresourcelocationflag:5,cueglstreamconnect:5,cueglstreamconsumeracquirefram:[5,6,12],cueglstreamconsumerconnect:[5,6,12],cueglstreamconsumerconnectwithflag:[5,6,12],cueglstreamconsumerdisconnect:[5,6,12],cueglstreamconsumerreleasefram:[5,6,12],cueglstreamproducerconnect:[5,6,12],cueglstreamproducerdisconnect:[5,6,12],cueglstreamproducerpresentfram:[5,6,12],cueglstreamproducerreturnfram:[5,6,12],cuevent:[5,6],cuevent_capture_flag:5,cuevent_flag:5,cuevent_record_flag:5,cuevent_sched_flag:5,cuevent_wait_flag:5,cueventcr:[5,6],cueventcreatefromeglsync:[5,12],cueventdestroi:[5,6],cueventelapsedtim:[5,6],cueventqueri:[5,6],cueventrecord:[5,6],cueventrecordwithflag:5,cueventsynchron:[5,6],cuexecaffinityparam:5,cuexecaffinityparam_st:5,cuexecaffinityparam_v1:5,cuexecaffinitysmcount:5,cuexecaffinitysmcount_st:5,cuexecaffinitysmcount_v1:5,cuexecaffinitytyp:5,cuexternalmemori:5,cuexternalmemorygetmappedbuff:5,cuexternalmemorygetmappedmipmappedarrai:5,cuexternalmemoryhandletyp:5,cuexternalsemaphor:5,cuexternalsemaphorehandletyp:5,cufilter_mod:5,cuflushgpudirectrdmawrit:[5,6],cuflushgpudirectrdmawritesopt:5,cuflushgpudirectrdmawritesscop:5,cuflushgpudirectrdmawritestarget:5,cuformat:5,cufreeasync:[5,6],cufunc_cach:5,cufuncgetattribut:[5,6],cufuncgetmodul:5,cufuncsetattribut:5,cufuncsetblockshap:5,cufuncsetcacheconfig:[5,6],cufuncsetsharedmemconfig:[5,6],cufuncsetshareds:5,cufunct:[5,6],cufunction_attribut:5,cufunctionsetattribut:5,cugeterrornam:[5,6],cugeterrorstr:[5,6],cugetprocaddress:[5,6],cuglctxcreat:12,cugldevicelist:5,cuglgetdevic:[5,6,12],cuglinit:12,cuglmapbufferobject:12,cuglmapbufferobjectasync:12,cuglregisterbufferobject:12,cuglsetbufferobjectmapflag:12,cuglunmapbufferobject:12,cuglunmapbufferobjectasync:12,cuglunregisterbufferobject:12,cugpudirectrdmawritesord:5,cugraph:[5,6],cugraphaddbatchmemopnod:5,cugraphaddchildgraphnod:5,cugraphadddepend:5,cugraphaddemptynod:5,cugraphaddeventrecordnod:5,cugraphaddeventwaitnod:5,cugraphaddexternalsemaphoressignalnod:5,cugraphaddexternalsemaphoreswaitnod:5,cugraphaddhostnod:5,cugraphaddkernelnod:5,cugraphaddmemallocnod:5,cugraphaddmemcpynod:5,cugraphaddmemfreenod:5,cugraphaddmemsetnod:5,cugraphbatchmemopnodegetparam:5,cugraphbatchmemopnodesetparam:5,cugraphchildgraphnodegetgraph:5,cugraphclon:5,cugraphcr:5,cugraphdebugdot_flag:5,cugraphdebugdotprint:5,cugraphdestroi:5,cugraphdestroynod:5,cugrapheventrecordnodegetev:5,cugrapheventrecordnodesetev:5,cugrapheventwaitnodegetev:5,cugrapheventwaitnodesetev:5,cugraphexec:[5,6],cugraphexecbatchmemopnodesetparam:5,cugraphexecchildgraphnodesetparam:5,cugraphexecdestroi:5,cugraphexeceventrecordnodesetev:5,cugraphexeceventwaitnodesetev:5,cugraphexecexternalsemaphoressignalnodesetparam:5,cugraphexecexternalsemaphoreswaitnodesetparam:5,cugraphexechostnodesetparam:5,cugraphexeckernelnodesetparam:5,cugraphexecmemcpynodesetparam:5,cugraphexecmemsetnodesetparam:5,cugraphexecupd:5,cugraphexecupdateresult:5,cugraphexternalsemaphoressignalnodegetparam:5,cugraphexternalsemaphoressignalnodesetparam:5,cugraphexternalsemaphoreswaitnodegetparam:5,cugraphexternalsemaphoreswaitnodesetparam:5,cugraphgetedg:5,cugraphgetnod:5,cugraphgetrootnod:5,cugraphhostnodegetparam:5,cugraphhostnodesetparam:5,cugraphicsd3d10registerresourc:5,cugraphicsd3d11registerresourc:5,cugraphicsd3d9registerresourc:5,cugraphicseglregisterimag:[5,6,12],cugraphicsglregisterbuff:[5,6,12],cugraphicsglregisterimag:[5,6,12],cugraphicsmapresourc:[5,6],cugraphicsmapresourceflag:5,cugraphicsregisterflag:5,cugraphicsresourc:[5,6],cugraphicsresourcegetmappedeglfram:[5,6,12],cugraphicsresourcegetmappedmipmappedarrai:[5,6],cugraphicsresourcegetmappedpoint:5,cugraphicsresourcesetmapflag:[5,6],cugraphicssubresourcegetmappedarrai:[5,6],cugraphicsunmapresourc:[5,6],cugraphicsunregisterresourc:[5,6],cugraphicsvdpauregisteroutputsurfac:[5,6,12],cugraphicsvdpauregistervideosurfac:[5,6,12],cugraphinstanti:5,cugraphinstantiate_flag:[5,6],cugraphinstantiatewithflag:5,cugraphkernelnodecopyattribut:5,cugraphkernelnodegetattribut:5,cugraphkernelnodegetparam:5,cugraphkernelnodesetattribut:5,cugraphkernelnodesetparam:5,cugraphlaunch:5,cugraphmem_attribut:5,cugraphmemallocnodegetparam:5,cugraphmemcpynodegetparam:5,cugraphmemcpynodesetparam:5,cugraphmemfreenodegetparam:5,cugraphmemsetnodegetparam:5,cugraphmemsetnodesetparam:5,cugraphnod:[5,6],cugraphnodefindinclon:5,cugraphnodegetdepend:5,cugraphnodegetdependentnod:5,cugraphnodegeten:5,cugraphnodegettyp:5,cugraphnodeseten:5,cugraphnodetyp:5,cugraphreleaseuserobject:5,cugraphremovedepend:5,cugraphretainuserobject:5,cugraphupload:5,cuhostfn:5,cuimportexternalmemori:5,cuimportexternalsemaphor:5,cuinit:[5,9],cuipcclosememhandl:[5,6],cuipceventhandl:5,cuipceventhandle_st:5,cuipceventhandle_v1:5,cuipcgeteventhandl:[5,6],cuipcgetmemhandl:[5,6],cuipcmem_flag:5,cuipcmemhandl:5,cuipcmemhandle_st:5,cuipcmemhandle_v1:5,cuipcopeneventhandl:[5,6],cuipcopenmemhandl:[5,6],cujit_cachemod:5,cujit_cachemode_enum:5,cujit_fallback:5,cujit_opt:5,cujit_target:5,cujitinputtyp:5,cukernelnodeattrid:5,cukernelnodeattrvalu:5,cukernelnodeattrvalue_v1:5,cukernelnodegetattribut:[],cukernelnodesetattribut:[],culaunchattribut:5,culaunchattribute_st:5,culaunchattributeid:5,culaunchattributevalu:5,culaunchattributevalue_union:5,culaunchconfig:5,culaunchconfig_st:5,culaunchcooperativekernel:5,culaunchcooperativekernelmultidevic:5,culaunchhostfunc:[5,6],culaunchkernel:[5,9],culaunchkernelex:5,culimit:5,culink:5,culinkadddata:5,culinkaddfil:5,culinkcomplet:5,culinkcr:5,culinkdestroi:5,culinkst:5,cumem_advis:5,cumem_range_attribut:5,cumemaccess_flag:5,cumemaccessdesc:5,cumemaccessdesc_st:5,cumemaccessdesc_v1:5,cumemaddressfre:5,cumemaddressreserv:5,cumemadvis:[5,6],cumemalloc:[5,6,9],cumemalloc_v2:[5,6],cumemallocasync:[5,6],cumemallocationcomptyp:5,cumemallocationgranularity_flag:5,cumemallocationhandletyp:[5,6],cumemallocationprop:5,cumemallocationprop_st:5,cumemallocationprop_v1:5,cumemallocationtyp:5,cumemallocfrompoolasync:[5,6],cumemallochost:[5,6],cumemallocmanag:[5,6],cumemallocpitch:[5,6],cumemattach_flag:5,cumemcpi:[5,6],cumemcpy2d:[5,6],cumemcpy2dasync:[5,6],cumemcpy2dunalign:[5,6],cumemcpy3d:[5,6],cumemcpy3dasync:[5,6],cumemcpy3dp:[5,6],cumemcpy3dpeerasync:[5,6],cumemcpyasync:[5,6],cumemcpyatoa:5,cumemcpyatod:5,cumemcpyatoh:5,cumemcpyatohasync:5,cumemcpydtoa:5,cumemcpydtod:[5,6],cumemcpydtodasync:[5,6],cumemcpydtoh:[5,6],cumemcpydtohasync:[5,6,9],cumemcpyhtoa:5,cumemcpyhtoaasync:5,cumemcpyhtod:[5,6],cumemcpyhtodasync:[5,6,9],cumemcpyp:[5,6],cumemcpypeerasync:[5,6],cumemcr:[5,6],cumemexporttoshareablehandl:5,cumemfre:[5,6,9],cumemfreeasync:[5,6],cumemfreehost:[5,6],cumemgenericallocationhandl:5,cumemgenericallocationhandle_v1:5,cumemgetaccess:5,cumemgetaddressrang:5,cumemgetallocationgranular:5,cumemgetallocationpropertiesfromhandl:5,cumemgethandleforaddressrang:5,cumemgetinfo:[5,6],cumemhandletyp:5,cumemhostalloc:[5,6],cumemhostgetdevicepoint:[5,6],cumemhostgetflag:[5,6],cumemhostregist:[5,6],cumemhostunregist:[5,6],cumemimportfromshareablehandl:5,cumemloc:5,cumemlocation_st:5,cumemlocation_v1:5,cumemlocationtyp:[5,6],cumemmap:5,cumemmaparrayasync:[5,6],cumemoperationtyp:5,cumemorypool:[5,6],cumemorytyp:5,cumemorytype_enum:5,cumempool:5,cumempool_attribut:5,cumempoolcr:[5,6],cumempooldestroi:[5,6],cumempoolexportpoint:[5,6],cumempoolexporttoshareablehandl:[5,6],cumempoolgetaccess:[5,6],cumempoolgetattribut:[5,6],cumempoolimportfromshareablehandl:[5,6],cumempoolimportpoint:[5,6],cumempoolprop:5,cumempoolprops_st:5,cumempoolprops_v1:5,cumempoolptrexportdata:5,cumempoolptrexportdata_st:5,cumempoolptrexportdata_v1:5,cumempoolsetaccess:[5,6],cumempoolsetattribut:[5,6],cumempooltrimto:[5,6],cumemprefetchasync:[5,6],cumemprot:[5,6],cumemrangegetattribut:[5,6],cumemrangehandletyp:5,cumemreleas:5,cumemretainallocationhandl:5,cumemsetaccess:5,cumemsetd16:[5,6],cumemsetd16async:[5,6],cumemsetd2d16:[5,6],cumemsetd2d16async:[5,6],cumemsetd2d32:[5,6],cumemsetd2d32async:[5,6],cumemsetd2d8:[5,6],cumemsetd2d8async:[5,6],cumemsetd32:[5,6],cumemsetd32async:[5,6],cumemsetd8:[5,6],cumemsetd8async:[5,6],cumemunmap:5,cumipmappedarrai:5,cumipmappedarraycr:[5,6],cumipmappedarraydestroi:[5,6],cumipmappedarraygetlevel:[5,6],cumipmappedarraygetmemoryrequir:5,cumipmappedarraygetsparseproperti:5,cumodul:5,cumodulegetfunct:[5,9],cumodulegetglob:5,cumodulegetloadingmod:5,cumodulegetsurfref:5,cumodulegettexref:5,cumoduleload:5,cumoduleloaddata:[5,9],cumoduleloaddataex:5,cumoduleloadfatbinari:5,cumoduleloadingmod:5,cumoduleunload:[5,9],cuoccupancy_flag:5,cuoccupancyavailabledynamicsmemperblock:5,cuoccupancyb2ds:5,cuoccupancymaxactiveblockspermultiprocessor:[5,6],cuoccupancymaxactiveblockspermultiprocessorwithflag:[5,6],cuoccupancymaxactiveclust:5,cuoccupancymaxpotentialblocks:5,cuoccupancymaxpotentialblocksizewithflag:5,cuoccupancymaxpotentialclusters:5,cuparamsetf:5,cuparamseti:5,cuparamsets:5,cuparamsetv:5,cupi:8,cupointer_attribut:5,cupointergetattribut:[5,6],cupointersetattribut:5,cuprofileriniti:[5,12],cuprofilerstart:[5,6,12],cuprofilerstop:[5,6,12],curesourcetyp:[5,6],curesourceviewformat:5,curesult:[5,9],current:[4,5,6,7,9],cushared_carveout:5,cusharedconfig:5,cusignalexternalsemaphoresasync:5,custream:[5,6],custream_flag:5,custreamaddcallback:[5,6],custreamattachmemasync:[5,6],custreamattrid:5,custreamattrvalu:5,custreamattrvalue_v1:5,custreambatchmemop:5,custreambatchmemop_v2:5,custreambatchmemopparam:5,custreambatchmemopparams_union:5,custreambatchmemopparams_v1:5,custreambatchmemoptyp:5,custreambegincaptur:[5,6],custreamcallback:5,custreamcapturemod:5,custreamcapturestatu:5,custreamcopyattribut:5,custreamcr:[5,6,9],custreamcreatewithprior:[5,6],custreamdestroi:[5,6,9],custreamendcaptur:5,custreamgetattribut:5,custreamgetcaptureinfo:5,custreamgetcaptureinfo_v2:5,custreamgetctx:5,custreamgetflag:[5,6],custreamgetprior:[5,6],custreamiscaptur:5,custreamlaunchhostfunc:5,custreammemopflushremotewritesparams_st:5,custreammemopmemorybarrierparams_st:5,custreammemopwaitvalueparams_st:[5,13],custreammemopwritevalueparams_st:5,custreammemorybarri:5,custreammemorybarrier_flag:5,custreamqueri:[5,6],custreamsetattribut:5,custreamsynchron:[5,6,9],custreamupdatecapturedepend:5,custreamupdatecapturedependencies_flag:5,custreamwaitev:[5,6],custreamwaitvalue32:5,custreamwaitvalue32_v2:5,custreamwaitvalue64:5,custreamwaitvalue64_v2:5,custreamwaitvalue_flag:5,custreamwritevalue32:5,custreamwritevalue32_v2:5,custreamwritevalue64:5,custreamwritevalue64_v2:5,custreamwritevalue_flag:5,cusurfobject:[5,6],cusurfobject_v1:5,cusurfobjectcr:[5,6],cusurfobjectdestroi:[5,6],cusurfobjectgetresourcedesc:[5,6],cusurfref:5,cusurfrefsetarrai:5,cusynchronizationpolici:5,cutexobject:[5,6],cutexobject_v1:5,cutexobjectcr:[5,6],cutexobjectdestroi:[5,6],cutexobjectgetresourcedesc:[5,6],cutexobjectgetresourceviewdesc:[5,6],cutexobjectgettexturedesc:[5,6],cutexref:5,cutexrefsetaddress2d:5,cutexrefsetarrai:5,cutexrefsetflag:5,cuthreadexchangestreamcapturemod:5,cuuint64_t:[5,6,13],cuuserobject:5,cuuserobject_flag:5,cuuserobjectcr:5,cuuserobjectreleas:5,cuuserobjectretain:5,cuuserobjectretain_flag:5,cuuuid:[5,6],cuuuid_st:[5,6],cuvdpauctxcr:[5,12],cuvdpaugetdevic:[5,6,12],cuwaitexternalsemaphoresasync:5,cuwglgetdevic:12,cyclic:5,cython:[8,11,12],d3d11:[5,6],d3d12:[5,6],d3dkmt_handl:[5,6],d:[6,7],daemon:[5,6],dash:7,data:[0,8,9],datas:[5,6],datatyp:[5,6],dc:7,deadlock:5,debug:[4,5,6,7],decid:[5,6],declar:[5,6,16],decomposit:14,decreas:[5,6],decrement:[5,6],dedic:[5,6],deefault:6,deem:1,deep:[8,9],def:[7,9],default_program:7,defer:[5,6],defin:[1,5,6,7,16,17],definit:[5,6,7],degrad:[5,6],deiniti:6,delet:[5,6],deliv:9,denorm:[5,7],denot:[5,6,7],depend:[4,5,6,16],dependencies_out:[5,6],dependentnod:5,deprec:[5,6,13],depth:[5,6],depth_textur:5,dereferenc:[5,6],deriv:[5,6],derogatori:1,desc:[5,6],desclist:6,describ:[2,5,6,7],descript:[5,6],descriptor:[5,6],design:[5,9],desir:[5,6],destin:[5,6],destroi:[5,6,7],destructor:[5,6],detail:[1,5,6,9],detect:[5,6,9],determin:[1,5,6,7],determinist:[5,6],dev:[5,6],develop:[5,6,8,9],deviat:[5,6],devic:[0,7,9],devicebitmask:5,devicelist:[5,6],devicenodemask:5,deviceoverlap:6,devicepoint:6,devptr:[5,6],dfma:7,dgpu:[5,6],diag:7,diagnost:[5,6,7],dialect:7,did:[5,6],differ:[1,5,6,8,9],dim3:6,dim:[5,9],dimens:[5,6],dimension:[5,6],dir:7,direct3d:0,direct:[5,6,7],directli:[5,6,7],directmanagedmemaccessfromhost:6,directori:[4,7,17],directx:[5,6],disabl:[1,5,6,7,17],disabletrilinearoptim:6,disallow:[5,6],disconnect:[5,6],discourag:6,discret:[5,6],discuss:[5,6],disjoint:[5,6],displai:[5,6,7],disregard:6,distinct:[5,6],div:[5,7],divis:[5,7],dlcm:[5,6],dlink:7,dlto:[5,7],dma:5,dma_buf:5,doc:[3,5,6],docs_src:4,document:[2,4,5,6],doe:[5,6,9],doesn:[5,6,9],domain:[5,6],don:[5,6],done:[5,6,13],dopt:7,dot:[5,6],doubl:[5,6],dout:9,doutclass:9,down:[5,6],downstream:5,dpitch:6,dptr:[5,6],dptr_out:[5,6],dq:7,drive:5,driver:[0,4,8,9],driver_typ:16,driververs:[5,6],dst:[5,6],dstarrai:[5,6],dstcontext:5,dstdevic:[5,6],dstheight:5,dsthost:5,dstlod:5,dstmemorytyp:5,dstoffset:5,dstpitch:5,dstpo:6,dstptr:6,dstxinbyt:5,dsty:5,dstz:5,dtype:9,due:[5,6],duplic:[5,6],durat:[5,6],dure:[5,6,7,16],dw:7,dx:9,dxclass:9,dy:9,dyclass:9,dynam:[5,6,9],dynamicsmems:[5,6],e:[1,4,5,6,7,17],ea:11,each:[5,6,7,9],earlier:[5,6,9],easi:[8,9],easier:9,ecc:[5,6],eccen:6,econom:1,ecosystem:[8,9],edg:[5,6],edit:[1,4],educ:1,effect:[5,6],effici:[5,6],eg:[5,6],egl:[0,12,13],egl_fals:5,egl_support_reuse_nv:5,egl_tru:5,eglcolorformat:[5,6],eglfram:[5,6],eglimag:[5,6],eglimagekhr:[5,6],eglint:[5,6],eglsream:[5,6],eglstream:[5,6],eglstreamkhr:[5,6],eglsync:[5,6],eglsynckhr:[5,6],eight:[5,6],either:[5,6,7],elaps:[5,6],electron:1,element:[5,6],elements:[5,6],elementsizebyt:5,elif:9,elimin:9,els:[5,9],emb:7,embed:[5,6,7],emit:7,empathi:1,emploi:[5,6],empti:[5,6],emul:6,enabl:[5,6,7,9,17],encod:[5,6,9],encount:[2,5,6],encourag:[5,6],end:[5,6,7],endpoint:[5,6],enforc:[3,6],engin:[5,6,8,9],enough:[5,6],enqueu:[5,6],ensur:[5,6,9],entir:[5,6,7,9],entiti:7,entri:[0,8],enumer:[5,6,7],env:[4,5],environ:[1,4,5,6,13],equal:[5,6,7],equival:[5,6,7],err:[7,9],error:[0,9,16],errornod:5,especi:[5,6],establish:[5,6],estim:[5,6],etc:[5,6],ethnic:1,evalu:2,even:[5,6,7,9],evenli:5,event:[0,1,9],event_out:[5,6],eventu:[5,6],everi:[5,6],everyon:1,evict:[5,6],ewp:7,ex:[5,6],exact:[5,6],exactli:[5,6],examin:[5,6],exampl:[1,5,6,9,13],exce:[5,6],exceed:[5,6],except:[5,6,9],excess:[5,6],exchang:[5,6],exclud:[5,6],exclus:[5,6],execut:[0,7,8,9,13],exhaust:[5,6],exhibit:5,exist:[5,6,8],exit:6,expand:[5,6],expans:5,expect:[1,5,6,9],experi:[1,9],explan:13,explicit:[1,5,6],explicitli:[5,6,7],exportdata:6,expos:5,express:[1,5,6,7],extend:[5,6],extens:[4,5,6,7],extent:[5,6],extentdepth:5,extentheight:5,extentwidth:5,extern:[0,9],extmem:[5,6],extmem_out:[5,6],extra:[5,6,7,9],extract:[7,9],extsem:[5,6],extsem_out:[5,6],extsemarrai:[5,6],f:[4,5,6],face:[1,5,6,16],facil:5,facilit:[5,6],fact:6,fail:[5,6,9],failur:[5,6],fair:1,faith:1,fall:[2,5,6],fallback:[5,6],fals:[5,7,9],famili:[5,6],faq:1,fashion:[5,6],fast:[5,7],faster:[5,6,7,8],fastest:[5,6],fat:5,fatal:[5,6],fatbin:5,fatcubin:5,fault:[5,6],fd:[5,6],featur:[2,5,6,7],fenc:[5,6],fetch:[5,6],fewer:[5,6,8],fewest:5,ffma:7,field:[5,6],fifo:[5,6],fig:9,file:[2,5,6],filenam:5,fill:[5,6],filter:[5,6],filtermod:[5,6],find:[5,6],findresourc:5,finish:[5,6,9],finit:[5,6],first:[5,6,7,9],firstlay:[5,6],firstmipmaplevel:[5,6],fit:[5,6],fix:[2,5,6,14,16],flag:[5,6],flage:6,flight:5,float16:5,float32:9,floor:[5,6],flush:[5,6,7],flushremotewrit:5,fma:5,fmad:[7,9],fmtdesc:6,fn:[5,6],fname:5,fo:5,focus:1,follow:[1,4,5,6,7,9,16],foo:5,foobaz:5,footprint:8,forbid:[5,6],forbidden:[5,6],forc:[5,6],fork:[5,6],form:[5,6,7,9],format:[5,6,9],formatdesc:6,former:5,forward:[5,6,7],foster:1,found:[5,6,16],foundat:[8,9],four:[5,6],frame:[5,6],frametyp:[5,6],free:[1,5,6],freed:[5,6],frequenc:[5,6],frequent:[5,6],from:[1,3,5,6,7,8,9,13,16],from_:[5,6],ftz:[5,7],full:[5,8,9],fulli:5,func:[5,6],func_nam:6,funcptr:6,fundament:9,further:[1,5,6],futur:[3,5,6,8,11,12,16],g:[4,5,6,7],ga:12,gather:[5,6],gbrg:[5,6],gdb:4,gemini:6,gender:1,gener:[0,5,6,9],get:[5,6,7,8,9],getptr:[5,6,7],getsharedhandl:[5,6],gh:4,git:4,gitlab:16,give:[5,6],given:[5,6,7],gl:[12,13],gl_alpha:[5,6],gl_intens:[5,6],gl_lumin:[5,6],gl_luminance_alpha:[5,6],gl_r16:[5,6],gl_r8:[5,6],gl_r:[5,6],gl_red:[5,6],gl_renderbuff:[5,6],gl_rg16:[5,6],gl_rg8:[5,6],gl_rg:[5,6],gl_rgba:[5,6],gl_texture_2d:[5,6],gl_texture_2d_arrai:[5,6],gl_texture_3d:[5,6],gl_texture_cube_map:[5,6],gl_texture_rectangl:[5,6],glcontext:[5,6],glenum:[5,6],glfinish:[5,6],global:[5,6,7],globall1cachesupport:6,gluint:[5,6],go:[5,6,9],goal:[8,9],good:[1,5,6,7],gpu:[5,6,7,8,9],gpudirect:[5,6],gr:[5,6],grab:9,gracefulli:1,grant:[5,6],granular:[5,6],graph:0,graph_out:[5,6],graphexec:[5,6],graphic:[0,13],grbg:[5,6],greater:[5,6,7],greatest:[5,6],greatestprior:[5,6],grid:[5,6,9],grid_group:6,griddepcontrol:[5,6],griddim:6,griddimi:5,griddimx:5,griddimz:5,group:[5,6],guarante:[5,6],guid:[4,5,6],guidanc:4,h:[5,6,16],ha:[5,6,8,9,16,17],had:[5,6],half:[5,6],halt:9,hand:[5,6,8],handl:[0,9,13],handle_out:[5,6],handletyp:[5,6],handwritten:5,happen:[5,6],harass:1,hardwar:[5,6],harm:1,harrai:[5,6],have:[1,5,6,7,8,9,16,17],haven:[5,6],hclonedgraph:5,hdst:6,header:[5,6,7,16,17],heap:[5,6],height:[5,6],held:[5,6],help:[5,6,8,9],helper:7,henc:[5,7],hend:5,here:[5,6,9],herrornode_out:[5,6],heurist:[5,6],hevent:5,hexadecim:[5,6],hfunc:5,hgraph:[5,6],hgraphexec:[5,6],high:[5,6],higher:[5,6,7,9],highest:[5,6],highli:6,hightlight:10,hint:[5,6],hit:[5,6],hitprop:[5,6],hitratio:[5,6],hmipmappedarrai:5,hmod:5,hnode:[5,6],hoffset:6,hoffsetdst:6,hoffsetsrc:6,hold:[5,6],honor:5,horiginalgraph:5,horiginalnod:5,host:[5,6,8,9],hostnativeatomicsupport:6,hostpoint:6,hostptr:6,hout:9,how:[5,6,9],howev:[5,6,7],hpc:8,hsrc:6,hstart:5,hstream:[5,6],html:[1,4,5],http:[1,5,6,16],hx:9,hy:9,hz:9,i:[5,6,7,17],id3d11fenc:[5,6],id3d11resourc:[5,6],id3d12devic:[5,6],id3d12fenc:[5,6],id3d12heap:[5,6],id3d12resourc:[5,6],id:[5,6],id_out:[5,6],ident:[1,5,6,7,9],identif:5,identifi:[5,6],idl:[5,6],idxgikeyedmutex:[5,6],idxgiresourc:[5,6],idxgiresource1:[5,6],ieee:[5,7],ignor:[5,6,9],igpu:[5,6],illeg:[5,6],imag:[5,6],imageri:1,immedi:[5,6,9],impact:[5,6],imper:5,impl_priv:6,implement:[2,5,6],impli:[5,6,7],implic:6,implicit:[5,6,7],implicitli:[5,6],implict:5,importantli:9,impos:[5,6],improp:5,improv:[5,6,9],inact:5,inappropri:1,inbetween:6,incid:1,includ:[1,5,6,7,16,17],includenam:7,inclus:[1,8],incompat:[5,6,9],incomplet:[5,6],inconsist:[5,6],incorpor:5,incorrect:6,increas:[5,6,7,9],increasingli:8,increment:[5,6],incur:[5,6],indefinit:[5,6],independ:[5,6],index:[3,4,5,6],indic:[5,6,7],indirectli:5,individu:[1,5,6,7,9],infer:[5,6],infinit:[5,6],info:[5,6,7],inform:[0,1,5,6,9],infrequ:[5,6],inhibit:7,initi:[0,6,7,9,11],initializer_list:7,initialrefcount:[5,6],inlin:7,inplac:4,input:[5,6,7,9],insert:[5,6],insid:[5,6],insight:9,inspect:[5,6],instal:[3,5,6,18],instanc:[1,5,6,7],instanti:[5,6],instead:[5,6,7,16],instruct:[5,6,9,18],insuffici:[5,6],insult:1,int128:7,int32_t:5,int64_t:5,int_max:[5,6],integ:[5,6],integr:[5,6],intend:[5,6],inter:[5,6],interact:[0,5,9],interchang:6,interest:[1,2],interfac:[5,6,8,9],interleav:[5,6],intermedi:[5,7],intern:[5,6],interop:[5,6],interoper:[0,9,10],interpret:[5,6,9],interprocess:[5,6],interv:[5,6],intra:[5,6],introduc:[5,6,9],introduct:9,intuit:9,invalid:[5,6],investig:1,invoc:5,invok:[5,6],involv:[5,6],ipc:[5,6],isa:9,isen:[5,6],isinst:9,ismultigpuboard:6,isn:[5,6],isp:[5,6],isssu:6,issu:[1,2,5,6,16,17,18],item:[5,6],items:9,iter:8,its:[1,5,6,8,9],janurai:13,jargon:8,jit:[5,6],join:[5,6],jump:9,june:16,just:[5,6],keep:[5,6],kei:[5,6,9],kernel:[5,6,7],kernelexectimeouten:6,kernelparam:[5,6],keyedmutex:[5,6],keyword:[5,6],kilohertz:[5,6],kind:[5,6,7],kmt:[5,6],know:[5,6],known:[5,6],kwarg:[5,6,7],l1:[5,6],l2:[5,6],l2caches:6,languag:[1,7,8,9],laps:[5,6],larg:[5,6],larger:[5,6],largest:5,last:[5,6,9],lastlay:[5,6],lastmipmaplevel:[5,6],latenc:[5,6],later:[4,5,6,7,9],latest:[4,5,6,16,17,18],latter:5,launch:[5,6,9,13,14,15,16,17,18],launch_depend:[5,6],launchdep:5,launchparamslist:5,layer:[5,6],layout:[5,6],lazi:5,lazili:5,lead:5,leadership:1,learn:[5,8,9],least:[5,6],leastprior:[5,6],leav:[5,6],left:6,legaci:[5,6,13],legal:[5,6],length:[5,6],less:[5,6,7],let:[5,6],level:[1,5,6,9,11,12],levelarrai:6,leverag:[5,6,9],li:[5,6],librari:[4,5,6,8,9,14],licens:[5,6],lie:6,life:5,lifetim:[5,6],lighter:8,lightweight:[5,6],like:[5,6,9],likewis:[5,6],limit:[5,6,7,10],line:[5,6,7,9],linear:[5,6],lineinfo:[5,7],link:[5,6,7],link_sync_behavior:[5,6],linker:5,linux:[4,5,6,7],list:[5,6,7,9],load:[5,6,9,14],local:[4,5,6],locall1cachesupport:6,localsizebyt:6,locat:[5,6,9,17],lock:[5,6],lod:5,lode:5,log2:[5,6],log:[5,6,7,9],logbuff:5,logic:[5,6],logsizeret:7,longer:[5,6,16,17],look:[5,6],loop:6,low:[5,6,9,11,12],lower:[5,6,7,8],lowered_nam:7,lowest:[5,6],lpsecurityattribut:[5,6],lsb:[5,6],luid:[5,6],luiddevicenodemask:6,lumin:[5,6],mac:[5,6],machin:[5,9],macro:[5,6,7],made:[5,6],mai:[1,5,6,7,9,15,16],mail:1,maintain:[1,5,6],mainten:8,major:[4,5,6,7],make:[1,4,5,6,7],make_cudaext:6,make_cudapitchedptr:6,make_cudapo:6,malloc:[5,6],manag:0,managedmemori:6,mandat:[5,6],mangl:[5,7],mani:[5,6],manner:5,manual:[5,6,9],map:[5,6],mapinfolist:5,mappabl:5,march:14,mark:[5,6],mask:[5,6],massiv:9,match:[4,5,6,9],math:7,matrix:[5,6],matthew:9,max:[5,6],max_plan:5,maxanisotropi:[5,6],maxblockspermultiprocessor:6,maxdynamicsharedsizebyt:6,maxgrids:[5,6],maxim:[5,6,9],maximum:[5,6,7],maxmipmaplevelclamp:[5,6],maxrregcount:7,maxsurface1d:6,maxsurface1dlay:6,maxsurface2d:6,maxsurface2dlay:6,maxsurface3d:6,maxsurfacecubemap:6,maxsurfacecubemaplay:6,maxtexture1d:6,maxtexture1dlay:6,maxtexture1dlinear:6,maxtexture1dmipmap:6,maxtexture2d:6,maxtexture2dgath:6,maxtexture2dlay:6,maxtexture2dlinear:6,maxtexture2dmipmap:6,maxtexture3d:6,maxtexture3dalt:6,maxtexturecubemap:6,maxtexturecubemaplay:6,maxthreadsdim:[5,6],maxthreadsperblock:[5,6],maxthreadspermultiprocessor:6,maxwel:[5,6],maxwidthinel:[5,6],mean:[5,6],meaning:[5,6],meant:[5,6],measur:[5,6],mechan:[5,6],media:1,meet:[5,6],mem:5,memaddressreserv:5,membar:5,member:[1,5,6,7,13],memcpi:[5,6],memhandl:5,memhandledesc:[5,6],memhandletyp:5,memop:[5,6],memoperationtyp:5,memori:[0,7,8,9],memorybarri:5,memorybuswidth:6,memoryclockr:6,memoryrequir:[5,6],mempitch:[5,6],mempool:[5,6],memset:[5,6],memsetparam:5,merg:[5,6],messag:[5,6,7],met:[5,6],method:5,microsecond:[5,6],mig:5,might:[5,6],migrat:[5,6],millisecond:[5,6],minbytestokeep:[5,6],mind:[5,6],mingrids:5,minim:[5,6],minimum:[5,6,7,8],minmipmaplevelclamp:[5,6],minor:[4,5,6,7,17],mip:[5,6],miplevel:[5,6],mipmap:[5,6],mipmapdesc:[5,6],mipmapfiltermod:[5,6],mipmaplevelbia:[5,6],mipmappedarrai:6,miptail:5,miptailfirstlevel:[5,6],miptails:[5,6],mirror:[5,6],misc:7,misconfigur:[5,6],mismatch:[5,6],miss:[5,6,17],missprop:[5,6],mix:[5,6],mobil:[16,17],mode:[5,6,7],model:[5,6,9],modif:[5,6],modifi:[5,6,7],modprob:5,modul:[0,3,4,6,8,9],more:[5,6,7,8,9],most:[5,6,8,9],mostli:[5,6],motherboard:6,motiv:3,move:[5,6,7],movement:9,movntdqa:5,mp:[5,6],ms:[5,6],much:[5,6],multi:[5,6],multi_grid_group:6,multidimension:[5,6],multigpuboardgroupid:6,multipl:[5,6,9],multiplanar:[5,6],multipli:[5,7],multiprocessor:[5,6],multiprocessorcount:6,multisampl:[5,6],must:[4,5,6,7,9],mutex:[5,6],n:[5,6,7,9],name:[5,6,7],name_express:7,narrow:6,nation:1,nativ:[5,6],natur:[5,9],nearest:[5,6,7],nearli:9,necessari:[1,5,6],necessarili:[5,6],need:[2,5,6,9,16,17],neg:[5,6],neither:6,nest:[5,6],network:8,never:[5,6],newer:[5,6],newli:[5,6],next:[5,6,9],nice:9,node:[5,6],nodeparam:[5,6],nodeparams_out:5,non:[5,6,7],none:[5,6,9],nonzero:[5,6],nor:6,normal:[5,6],normalizedcoord:6,note:[3,4,5,6,7,9],noth:[5,6],notifi:2,now:[5,6,8,9,13,16,17],np:9,nsight:9,nsy:9,nt:[5,6],nullabl:5,num_block:9,num_byt:[5,6],num_thread:9,numarch:7,numattr:5,numattribut:[5,6],numba:8,number:[5,6,7],numblock:[5,6],numbyt:5,numchannel:[5,6],numclust:5,numdepend:[5,6],numdependencies_out:[5,6],numdependentnod:5,numdevic:5,numedg:[5,6],numer:[5,6],numextsem:[5,6],numhead:7,numlevel:[5,6],nummipmaplevel:5,numnod:[5,6],numopt:[5,7],numparam:5,numpi:[8,9],numreg:6,numrootnod:5,nv:5,nvcc:[5,6],nvcl:5,nvcl_ctx_sched_auto:5,nvcl_ctx_sched_blocking_sync:5,nvcl_ctx_sched_spin:5,nvcl_ctx_sched_yield:5,nvcl_event_sched_auto:5,nvcl_event_sched_blocking_sync:5,nvcl_event_sched_spin:5,nvcl_event_sched_yield:5,nvidia:[1,2,4,5,6,8,9,16],nvidia_p2p_get_pag:[5,6],nvlink:[5,6],nvreg_enablestreammemop:5,nvrtc:[0,3,4,9,16],nvrtc_error:7,nvrtc_error_builtin_operation_failur:7,nvrtc_error_compil:7,nvrtc_error_internal_error:7,nvrtc_error_invalid_input:7,nvrtc_error_invalid_opt:7,nvrtc_error_invalid_program:7,nvrtc_error_name_expression_not_valid:7,nvrtc_error_no_lowered_names_before_compil:7,nvrtc_error_no_name_expressions_after_compil:7,nvrtc_error_out_of_memori:7,nvrtc_error_program_creation_failur:7,nvrtc_success:[7,9],nvrtcaddnameexpress:7,nvrtccompileprogram:[7,9],nvrtccreateprogram:[7,9],nvrtcdestroyprogram:7,nvrtcgetcubin:7,nvrtcgetcubins:7,nvrtcgeterrorstr:7,nvrtcgetlowerednam:7,nvrtcgetnumsupportedarch:7,nvrtcgetnvvm:7,nvrtcgetnvvmsiz:7,nvrtcgetprogramlog:[7,9],nvrtcgetprogramlogs:7,nvrtcgetptx:[7,9],nvrtcgetptxsiz:[7,9],nvrtcgetsupportedarch:7,nvrtcprogram:7,nvrtcresult:[7,9],nvrtcversion:7,nvscibuf:[5,6],nvscibufobject:[5,6],nvscisync:[5,6],nvscisyncattr:[5,6],nvscisyncattrkey_requiredperm:[5,6],nvscisyncattrlist:[5,6],nvscisyncobj:[5,6],nvvm:[5,7],nvvmsizeret:7,o:[5,6],obei:[5,6],obj:[5,6],object:[0,9],object_out:[5,6],oblig:1,observ:[5,6],obtain:[4,5,6],occasion:[5,6],occassion:[5,6],occup:0,occupi:6,occur:[5,6],octet:5,octob:[12,17,18],off:[5,6,7],offens:1,offici:1,offlin:1,offset:[5,6],offseti:5,offsetx:5,offsetz:5,often:[5,6],old:5,older:[5,6],omit:[5,6,9],onc:[5,6],one:[5,6,7,8],ones:5,ongo:[5,6],onli:[4,5,6,7,9,11],onlin:[1,5],onto:[5,6],op:[5,6],opaqu:[5,6,7],open:[1,4,5,6],opengl:0,oper:[0,6,7,9],operand:[5,6],opportunist:[5,6],oppos:6,opt:[5,6,7,9],optim:[5,6,7],optin:[5,6],option:[0,5,6,13,14,15,16,17,18],optionvalu:5,order:[0,7],ordin:[5,6],org:1,orient:[1,9],origin:[5,6],originalgraph:[5,6],originalnod:6,orthogon:[5,6],os:[5,6],oshandl:5,ote_null_stream:5,ote_sync:6,other:[1,4,5,6,7],otherwis:[1,5,6,7],our:[3,8,9],out:[5,6,9],outlin:[4,5,6],output:[5,6,7,9],outsid:[5,6,9],outstand:[5,6],over:[5,6],overal:9,overflow:[5,6],overhead:[5,6,8],overlap:[5,6,9],overload:6,overrid:[5,6],overridden:5,oversubscript:[5,6],overview:[3,5,6],overwrit:[5,6],overwritten:[5,6],own:[5,6,8,9],ownership:[5,6],p2p:[5,6],p2ptoken:5,p:[5,6],pack:5,packag:[4,5,6,9,11],pad:[5,6],page:[3,4,5,6],pageabl:[5,6],pageablememoryaccess:6,pageablememoryaccessuseshostpaget:6,pair:[5,6],pairless:[5,6],pallocatearrai:5,parallel:[5,6,7,8,9],param:[5,6],paramarrai:5,paramet:[5,6,7,9],params_out:[5,6],paramsarrai:[5,6],parrai:5,parraydescriptor:5,pars:17,part:[5,6,9],parti:[5,6],particip:[1,5,6],particular:[5,6,7,16],partit:[5,6],pass:[4,5,6,7,9],path:[5,6,7,8],pattern:[5,6],pbase:5,pcacheconfig:6,pcapturestatu:6,pci:[5,6],pcibusid:[5,6],pcideviceid:6,pcidomainid:6,pcie:[5,6],pclonednod:6,pconfig:[5,6],pcopi:5,pcopyparam:6,pctx:5,pcudadevic:[5,6],pcudadevicecount:[5,6],pcudaresourc:[5,6],pdepend:6,pdependentnod:6,pdevic:[5,6],pdevptr:5,pdptr:5,peak:[5,6],peer:0,peercontext:5,peerdev:5,peerdevic:6,pend:[5,6],per:[5,6,9,13],percent:[5,6],percentag:[5,6],perform:[3,5,6,7],perman:1,permiss:[1,5,6],permit:[5,6],perrornod:6,persist:[5,6],persistingl2cachemaxs:6,persit:[5,6],person:1,perspect:6,pervious:5,pexecaffin:5,pflag:[5,6],pfn:5,pformat:5,pfrom:6,pgraph:6,pgraphclon:6,pgraphexec:6,pgraphnod:6,phandl:5,phase:[5,6,7],phclonednod:5,pherrornod:5,phevent:[5,6],phgraph:5,phgraphclon:5,phgraphexec:5,phgraphnod:[5,6],phnode:5,phost:6,phstream:5,physic:[1,5,6],pi:5,pick:[5,6],pid:6,piec:[5,6],pin:[5,6],pip:4,pipelin:[5,6],pipi:4,pitch2d:[5,6],pitch:[5,6],pitcheddevptr:6,pitchinbyt:[5,6],place:[5,6,9],placehold:5,plai:9,planar:[5,6],plane:[5,6],planecount:[5,6],planedesc:6,planeidx:[5,6],platform:[4,5,6,11,12,16,17],pleas:[5,6],pledg:3,plevelarrai:5,plogbuff:6,pmemsetparam:6,pmillisecond:5,pmipmappedarrai:5,pmipmappedarraydesc:5,pnode:6,pnodeparam:6,pnumdepend:6,pnumdependentnod:6,pnumrootnod:6,pobject_attribut:5,point:[0,7,9],pointer:[5,6,7,9],polici:[1,5,6],polit:1,pool:[5,6,7],pool_out:[5,6],poolprop:[5,6],pop:[5,6],popul:[5,6,7],popular:8,port:4,portabl:[5,6,9],portion:[5,6],posit:[1,5,6],posix:[5,6],possibl:[5,6,9],post:1,potenti:[5,6],power:[5,6],pp:5,ppitch:5,pplanearrai:[5,6],ppointer:5,practic:9,pre:[5,6,7],prec:[5,7],preced:[5,6,7],precis:[5,6,7],predefin:7,predict:5,preempt:[5,6],preemption:[5,6],prefer:[5,6,8],preferredshmemcarveout:6,prefetch:[5,6],preinclud:7,prep:9,prepar:9,preprocess:7,preprocessor:7,presdesc:[5,6],present:[5,6,7],preserv:[5,6,7],presviewdesc:[5,6],prevent:[5,6],previou:[5,6,7,17],previous:[5,6,7],primari:[0,6,9],primarili:[5,6],primit:[5,6,10],print:5,printf:[5,6],prior:[5,6],prioriti:[2,5,6],privat:1,problem:8,proce:[6,9],procedur:[5,6],process:[5,6,7,8,9],processor:[5,6],produc:[5,6],product:6,profession:1,profil:[0,9,13],prog:[7,9],program:[5,6,7,8,9],programm:[5,6,7],programmat:[5,6],programmaticev:[5,6],programmaticstreamserializationallow:[5,6],progress:[5,6],prohibit:[5,6],project:1,promis:[5,6],promot:[5,6],prone:[5,6],prootnod:6,prop:[5,6],propag:16,proper:6,properli:[5,6],properti:[5,6],proprietari:[5,6],protect:[5,6],proucer:[5,6],provid:[5,6,7,8,9],psize:5,psrc:5,pstr:5,pstream:[5,6],psurfobject:[5,6],psurfref:5,ptd:13,ptexdesc:[5,6],ptexobject:[5,6],ptexref:5,pto:6,ptr:[5,6],ptr_out:[5,6],ptx:[5,6,7,9],ptxa:7,ptxsize:9,ptxsizeret:7,ptxversion:6,ptype:6,publish:1,pure:[5,6],purpos:[5,6],push:[5,6],pvalu:[5,6],px:5,py:[4,5,6],pypi:[3,12],pytest:[],python:[1,2,4],queri:[0,5,6],question:1,quickli:[5,6],quot:9,r:[5,6],race:[1,5,6],rais:[6,9],rand:9,random:9,rang:[5,6],rapid:8,rather:[5,6],ratio:[5,6],rccb:[5,6],rdc:7,rdma:[5,6],re:[5,6,9,16],reach:[5,6],read:[5,6],readi:[5,6,9],readmod:6,real:[5,6],realloc:[5,6],reason:[1,5,6],receiv:[5,6],recent:[5,6,9],recepi:5,recipi:[5,6],reciproc:[5,7],recogn:[5,6],recommend:[5,6],reconstruct:5,record:[5,6],recov:[5,6],recurs:[5,6],redistribut:4,reduc:[5,6,7],reenabl:[5,6],refcount:[5,6],refer:[3,5,6],referenc:[5,6],reflect:[5,6],regard:[1,5,6],regardless:[1,5,6],region:[5,6],regist:[5,6,7],registr:[5,6],regsperblock:[5,6],regspermultiprocessor:6,reiniti:6,reject:1,rel:[5,6],relat:[5,6],relationship:6,relaunch:[5,6],relax:[13,16],releas:[2,3,5,6,7,8,9],reli:[5,6],religion:1,reloc:5,relocat:7,remain:[4,5,6],remark:7,rememb:9,remot:[5,6],remov:[1,5,6,13,17],render:[5,6],renderbuff:[5,6],reorder:5,repercuss:1,replac:[5,6,8],replai:[5,6],report:[1,2,5,6,7],repres:[1,5,6],represent:[1,5,6],request:[2,5,6],requestedhandletyp:5,requir:[3,5,6,7,9,17],reserv:[5,6],reserved0:5,reserved1:5,reservedsharedmemperblock:6,reset:[5,6,7],resid:[5,6,9],resiz:[5,6],resolut:[5,6],resolv:[5,6,16,17,18],resour:5,resourc:[0,9],resourcetyp:5,respect:[1,5,6],respons:[3,5,6],responsibl:5,rest:[5,6],restor:[5,6],restrict:[5,6,7],restyp:[5,6],result:[1,5,6,7,9],retain:[5,6],retri:[5,6,9],retriev:[5,6,9],returnd:6,reus:[5,6],revert:[5,6],review:1,revis:6,rgb:5,rgba:[5,6],rggb:[5,6],right:1,role:9,room:[5,6],root:[4,5,6,7],rootnod:5,round:[5,6,7],routin:0,row:[5,6],rule:[5,6],run:[4,5,6,9],runtim:[0,5,7,8,9,16],runtimeerror:9,runtimevers:6,s:[1,5,6,7,8,9,17],safe:[5,6],sake:[5,6],same:[5,6,7,9],sampl:[5,6],satisfi:[5,6],saxpi:9,scenario:[5,6],sched:5,schedul:[2,5,6],scienc:[8,9],scipi:8,scope:[3,5,6],screenshot:9,se:[5,6],seamless:[5,6],seamlesscubemap:6,search:[3,5,6,7],second:[5,6],secondarili:6,section:[5,6],secur:[5,6],see:[1,2,5,6,7,9,13],seen:6,segment:[5,6],select:[5,6,7],self:6,semant:[5,6],semaphor:[5,6],semhandledesc:[5,6],sent:[5,6],separ:[1,5,6,7],septemb:[],sequenc:[5,6],serial:[5,6,9],serv:[5,6],server:[5,6],set:[1,4,5,6,7,8,9,13],setrlimit:7,setup:[4,5,6],sever:[5,6],sex:1,sexual:1,shall:[5,6],shape:[5,6],share:[5,6,9],shareabl:[5,6],shareablehandl:[5,6],sharedata:[5,6],sharedata_out:[5,6],sharedmem:6,sharedmembyt:[5,6],sharedmemperblock:[5,6],sharedmemperblockoptin:6,sharedmempermultiprocessor:6,sharedsizebyt:6,shhandletyp:5,shorter:6,should:[5,6,7,9],show:[1,9],shown:5,shut:[5,6],side:[5,6],sign:[5,6],signal:[5,6],signatur:[5,13],signific:[5,6],significantli:[5,6],silent:6,simdwidth:5,similar:[5,6],similarli:5,simpli:[5,6],simplif:9,simplifi:8,simultan:[5,6],sinc:[5,6],singl:[5,6,7,8,9],singletodoubleprecisionperfratio:6,singli:[5,6],situat:[5,6],six:[5,6],size:[1,5,6,7,9],size_t:[5,6,9],sizeinbyt:[5,6],sizeof:[5,6],sizeout:5,skip:[5,6],sku:5,slate:[5,6],sli:[5,6],slice:[5,6],slot:[5,6],slow:5,slower:5,sm:[5,6],sm_35:7,sm_37:7,sm_50:7,sm_52:7,sm_53:7,sm_60:7,sm_61:7,sm_62:7,sm_70:7,sm_72:7,sm_75:7,sm_80:7,sm_87:7,sm_89:7,sm_90:[5,7],small:5,smaller:[5,6,8],smi:5,so:[5,6,9],soc:[5,6],social:1,socio:1,solv:8,some:[5,6,9],someth:[5,6],sometim:6,sophist:8,sort:7,sourc:[3,5,6,7,10,11],space:[1,5,6,7],span:5,sparingli:[5,6],spars:[5,6],sparselevel:5,sparseproperti:[5,6],special:[5,6],specif:[1,4,5,6,7,9],specifi:[5,6,7],speed:[5,8],spent:5,spin:[5,6],spitch:6,split:[5,6],spread:[5,6],sqrt:[5,7],squar:[5,7],src:[5,6,7],srcarrai:[5,6],srccontext:5,srcdevic:[5,6],srcheight:5,srchost:5,srclod:5,srcmemorytyp:5,srcoffset:5,srcpitch:5,srcpo:6,srcptr:6,srcxinbyt:5,srcy:5,srcz:5,srgb:[5,6],sse4:5,stack:[5,6,7],stage:[5,6],standalon:5,standard:[3,8,9],start:[5,6],startup:6,stat:9,state:[5,6],stateout:5,statu:[1,5,6],status:[5,6],std:7,step:[4,9],still:[4,5,6,17],storag:[5,6],store:[5,6,7,9],str:9,strategi:5,strcutur:5,stream:[0,9,10,12],streamprioritiessupport:6,string:[5,6,7,9,14],strongli:6,struct:[5,6],structcudachannelformatdescchanneldesc:6,structur:[5,6,13],stub:[5,6],style:6,sub:[5,6],subject:9,submit:[5,6],subregion:[5,6],subresourc:[5,6],subresourcetyp:5,subroutin:5,subscrib:5,subsequ:[5,6,7],subset:[5,6],substanti:6,subsystem:[5,6],subtract:[5,7],succe:[6,7],succeed:[5,6],success:[5,6],successfulli:[5,6],suggest:5,suit:[5,6],suitabl:[5,6],sum:[5,6],suport:5,supplant:[5,6],suppli:[5,6],support:[0,4,5,6,8,10],supportedarch:7,suppport:5,suppress:[5,6,7],surfac:0,surfacealign:6,surfacerefer:6,surfobject:[5,6],sustain:[5,6],swap:[5,6],symbol:[5,6,13,14,15,16,17,18],symmetr:[5,6],sync:[5,6],synchron:[5,6,13],syncpolici:[5,6],synonym:6,syntax:8,sysmem:[5,6],system:[5,6,9],t:[5,6,9],tabl:[5,6,9],tag:7,tail:[5,6],take:[1,5,6,7,9],taken:6,target:[5,6,7,8,9],task:[5,6],tcc:[5,6],tccdriver:6,team:[1,2],tear:6,tegra:[5,6],templat:6,template_arg_0:6,template_arg_n:6,tempor:[5,6],temporari:[1,16],temporarili:[1,5,6],tenet:[5,6],term:[6,16],termin:[5,6],tesla:[5,6],test:[4,5,6],texobject:[5,6],texref:5,text:5,textur:0,texture1d_mipmapped_width:5,texture1d_width:5,texturealign:[5,6],texturepitchalign:6,texturerefer:6,texunit:5,than:[5,6,7],thank:2,thei:[1,5,6,7],them:[2,5,6,7,9],themselv:5,therebi:7,therefor:[5,6,9,17],thi:[1,2,5,6,7,9,10],thing:9,third:[5,6],those:[5,6],though:[5,6],thrash:[5,6],thread:[5,6,7,9,13],threadidx:9,threaten:1,three:[5,6,7,9],threshold:[5,6],through:[5,6,13],thu:[5,6],tid:9,tile:[5,6],tileext:[5,6],time:[2,5,6,7],timelin:[5,6],timeout:[5,6],timeoutm:[5,6],timingdata:[5,6],titl:5,todai:9,togeth:8,token:[5,7],toler:9,too:[5,6],took:[5,6],tool:[5,6,9],toolchain:[5,6],toolkit:[4,5,6,8,13,15,17],top:[5,6,8,9],topolog:[5,6],total:[5,6],totalconstantmemori:5,totalconstmem:6,totalglobalmem:6,toward:[1,9],traceback:9,track:[5,6,13],trade:7,trail:7,tranfer:[5,6],transact:5,transfer:[5,6,9],transform:9,transit:[5,6],translat:[7,9],transmit:5,trap:6,travel:6,treat:[5,6,7],tri:[5,6],triag:2,trigger:[5,6],triggeratblockstart:[5,6],trilinear:[5,6],trim:[5,6],trimto:[5,6],tripl:9,troll:1,truncat:[5,6,7],tune:[5,6],ture:9,turn:[5,6,7],twice:[5,6],two:[2,5,6,7],txt:4,type:[0,2,7,9,16,17],typedef:[5,6],typedefstructcudaeglplanedesc_st:6,typenam:5,typic:[5,6],u:[5,6,7],uc:5,ui:5,uint32:9,uint64:9,unabl:[5,6],unaccept:1,unaffect:[5,6],unari:5,unavail:[5,6],unbound:[5,6],uncommon:9,uncorrect:[5,6],undefin:[5,6,7],under:[5,6],underli:[5,6],underlin:13,understand:9,undo:[5,6],unexpect:[5,6],unfre:[5,6],unhandl:6,unidirect:[5,6],unifi:[0,8,9],unifiedaddress:6,uniform:8,union:[5,6],uniqu:[5,6],unison:8,unit:[5,6,7,9],unknown:[5,6,7,9],unless:[5,6],unlik:[5,6],unload:[5,6],unmap:[5,6],unnecessari:5,unprivileg:5,unreach:[5,6],unrecogn:[6,7],unreferenc:5,unregist:[5,6],unreleas:5,unresolv:5,unsaf:[5,6],unset:[5,6],unsign:[5,6],unsignedintdepth:6,unsignedintheight:6,unsignedintnumchannel:6,unsignedintpitch:6,unsignedintreserv:6,unsignedintwidth:6,unspecifi:[5,6],unsupport:[5,6],until:[5,6,7,9],unus:[5,6],unwelcom:1,up:[5,6,7,9],updat:[5,6,7,18],updateresult_out:[5,6],upfront:[5,6],upgrad:[5,6],upload:[5,6],upon:[5,6],upper:[5,6],us:[0,1,4,7,8,9,16,17,18],usabl:[5,6],usag:[5,6],use_fast_math:7,usec:[5,6],user:[5,6,8],userdata:[5,6],usr:4,usual:[5,6],utf:[5,6],util:[5,8],uuid:[5,6],uv:[5,6],uva:5,uyvi:[5,6],v10u10:[5,6],v12u12:[5,6],v1:5,v2:5,v3:5,v:[5,6],va:5,val:[5,6],valid:[5,6,7],valu:[5,6,7,9,13],value64:13,value_out:[5,6],valueerror:9,vanish:6,vari:[5,6],variabl:[4,5,6,7,13],variant:5,variat:17,variou:5,vaspacetoken:5,vdpau:[0,12,13],vdpdevic:[5,6],vdpgetprocaddress:[5,6],vdpoutputsurfac:[5,6],vdpsurfac:[5,6],vdpvideosurfac:[5,6],vector:[7,9],verbos:5,veri:6,verif:9,verifi:[5,6],versa:[5,6],version:[0,1,4,7,9],versu:5,via:[1,4,5,6,7],vice:[5,6],video:[5,6],vidmem:[5,6],view:[5,6],viewpoint:1,violat:[5,6],virtual:[0,6,7,9],visibl:[5,6],vista:[5,6],visual:[5,6],vkflushmappedmemoryrang:[5,6],vkinvalidatemappedmemoryrang:[5,6],void_ptr:[5,6],volatil:[5,6],volta:[5,6],vu:[5,6],vui:5,vulkan:[5,6],vuya:[5,6],vyui:[5,6],w:[5,6,7],wa:[5,6,7,9],wai:[5,6,9],wait:[5,6],waiter:[5,6],waitparam:13,waitvalu:5,wall:5,want:[2,5,6,8,9],warn:[5,7],warp:[5,6],warpsiz:6,watermark:[5,6],wc:[5,6],we:[1,2,8,9],welcom:1,well:[5,6],were:[5,6],what:[1,2,3,5,6],wheel:8,when:[1,5,6,7,8,9,13],whenev:[5,6],where:[5,6],whether:[5,6],which:[1,5,6,7,9],who:1,whole:[5,6,7],whose:[5,6],why:[3,5,6],wide:[5,6],width:[5,6],widthinbyt:5,wiki:1,wildcard:5,win32:[5,6],win32handlemetadata:5,win32securityattribut:[5,6],window:[4,5,6],within:[1,5,6,9],without:[1,5,6,7],woffset:6,woffsetdst:6,woffsetsrc:6,won:[5,6],word:[5,6],work:[5,6,9],workaround:[16,17],workflow:3,world:8,would:[5,6,9],wrap:[5,6,9,13],wraparound:5,wrapper:[8,11,12],write:[5,6,9],writevalu:5,written:[5,6],wrong:5,wsl:14,www:1,x:[5,6,9,11,12],xptxa:[5,6,7],xsize:6,xsz:6,xx:9,y10:[5,6],y12:[5,6],y:[5,6,9],yet:[5,6,9],yield:[5,6],yml:4,you:[2,4,5,6,8,9],your:[2,4,6,9],ysize:6,ysz:6,yuv420planar:[5,6],yuv422planar:[5,6],yuv444planar:[5,6],yuv:[5,6],yuyv:[5,6],yvyu:[5,6],z:[5,6,9],zero:[5,6,7,9]},titles:["CUDA Python API Reference","Code of Conduct","Contributing","CUDA Python Manual","Installation","cuda","cudart","nvrtc","Motivation","Overview","Release Notes","CUDA Python 11.4.0 Release notes","CUDA Python 11.5.0 Release notes","CUDA Python 11.6.0 Release notes","CUDA Python 11.6.1 Release notes","CUDA Python 11.7.0 Release notes","CUDA Python 11.7.1 Release notes","CUDA Python 11.8.0 Release notes","CUDA Python 11.8.1 Release notes"],titleterms:{"0":[11,12,13,15,17],"1":[14,16,18],"10":6,"11":[6,11,12,13,14,15,16,17,18],"4":11,"5":12,"6":[13,14],"7":[15,16],"8":[17,18],"9":6,"default":13,"function":[11,12,13,14,15,16,17,18],In:4,Not:[11,12,13,14,15,16,17,18],access:[5,6],address:[5,6],alloc:[5,6],api:[0,6],applic:9,attribut:1,build:[4,16,17],c:6,captionhold:0,code:1,comparison:9,compil:7,conda:4,conduct:1,content:3,context:5,contribut:2,control:[5,6],cuda:[0,3,5,6,8,9,11,12,13,14,15,16,17,18],cudart:6,data:[5,6],develop:4,devic:[5,6],direct3d:6,doc:4,driver:[5,6],egl:[5,6],enforc:1,entri:[5,6],error:[5,6,7],event:[5,6],execut:[5,6],extern:[5,6],from:4,futur:9,gener:7,graph:[5,6],graphic:[5,6],handl:[5,6,7],hightlight:[11,12,13,14,15,16,17,18],indic:3,inform:7,initi:5,instal:4,interact:6,interoper:[5,6,13],kernel:9,limit:[11,12,13,14,15,16,17,18],manag:[5,6],manual:3,memori:[5,6],modul:5,motiv:8,note:[10,11,12,13,14,15,16,17,18],nvrtc:7,object:[5,6],occup:[5,6],opengl:[5,6],oper:5,option:7,order:[5,6],our:1,overview:[1,9],peer:[5,6],perform:9,place:4,pledg:1,point:[5,6],primari:5,primit:13,profil:[5,6],publish:4,pypi:4,python:[0,3,8,9,11,12,13,14,15,16,17,18],queri:7,refer:0,releas:[10,11,12,13,14,15,16,17,18],requir:4,resourc:[5,6],respons:1,routin:6,runtim:6,scope:1,sourc:[4,16,17],standard:1,stream:[5,6,13],support:[7,11,12,13,14,15,16,17,18],surfac:[5,6],tabl:3,textur:[5,6],thi:[11,12,13,14,15,16,17,18],type:[5,6],unifi:[5,6],us:[5,6],vdpau:[5,6],version:[5,6],virtual:5,what:8,why:8,workflow:9}})
\ No newline at end of file
diff --git a/docs_src/environment-docs.yml b/docs_src/environment-docs.yml
index 97c2b16a..2a3a8ad3 100644
--- a/docs_src/environment-docs.yml
+++ b/docs_src/environment-docs.yml
@@ -2,7 +2,7 @@ name: cuda-python-docs
 channels:
   - conda-forge
 dependencies:
-  - cython=0.29.23
+  - cython
   - myst-parser
   - numpy
   - numpydoc
@@ -16,3 +16,4 @@ dependencies:
     - myst-nb
     - enum-tools
     - sphinx_toolbox
+    - pyclibrary
diff --git a/docs_src/source/module/cuda.rst b/docs_src/source/module/cuda.rst
index 317ad61a..303995b0 100644
--- a/docs_src/source/module/cuda.rst
+++ b/docs_src/source/module/cuda.rst
@@ -2632,57 +2632,57 @@ Data types used by CUDA driver
 
         allow the hardware to load-balance the blocks in a cluster to the SMs
 
-.. autoclass:: cuda.cuda.CUstreamAttrID
+.. autoclass:: cuda.cuda.CUlaunchAttributeID
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_IGNORE
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_IGNORE
 
 
         Ignored entry, for convenient composition
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW
 
 
         Valid for streams, graph nodes, launches.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_COOPERATIVE
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_COOPERATIVE
 
 
         Valid for graph nodes, launches.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY
 
 
         Valid for streams.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION
 
 
         Valid for graph nodes, launches.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
 
 
         Valid for graph nodes, launches.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION
 
 
         Valid for launches. Setting programmaticStreamSerializationAllowed to non-0 signals that the kernel will use programmatic means to resolve its stream dependency, so that the CUDA runtime should opportunistically allow the grid's execution to overlap with the previous kernel in the stream, if that kernel requests the overlap.
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT
 
 
         Valid for launches. Event recorded through this launch attribute is guaranteed to only trigger after all block in the associated kernel trigger the event. A block can trigger the event through PTX griddepcontrol.launch_dependents. A trigger can also be inserted at the beginning of each block's execution if triggerAtBlockStart is set to non-0. Note that dependents (including the CPU thread calling :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the release precisely when it is released. For example, :py:obj:`~.cuEventSynchronize()` may only observe the event trigger long after the associated kernel has completed. This recording type is primarily meant for establishing programmatic dependency between device tasks. The event supplied must not be an interprocess or interop event. The event must disable timing (i.e. created with :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
 
 
-    .. autoattribute:: cuda.cuda.CUstreamAttrID.CU_LAUNCH_ATTRIBUTE_PRIORITY
+    .. autoattribute:: cuda.cuda.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PRIORITY
 
 
         Valid for graph nodes.
@@ -4833,8 +4833,10 @@ Data types used by CUDA driver
 .. autoclass:: cuda.cuda.CUlaunchAttributeValue
 .. autoclass:: cuda.cuda.CUlaunchAttribute
 .. autoclass:: cuda.cuda.CUlaunchConfig
+.. autoclass:: cuda.cuda.CUkernelNodeAttrID
 .. autoclass:: cuda.cuda.CUkernelNodeAttrValue_v1
 .. autoclass:: cuda.cuda.CUkernelNodeAttrValue
+.. autoclass:: cuda.cuda.CUstreamAttrID
 .. autoclass:: cuda.cuda.CUstreamAttrValue_v1
 .. autoclass:: cuda.cuda.CUstreamAttrValue
 .. autoclass:: cuda.cuda.CUexecAffinitySmCount_v1
diff --git a/docs_src/source/module/cudart.rst b/docs_src/source/module/cudart.rst
index 358482ca..325d7cb3 100644
--- a/docs_src/source/module/cudart.rst
+++ b/docs_src/source/module/cudart.rst
@@ -19,6 +19,8 @@ impl_private
 
 
 
+
+
 This section describes the device management functions of the CUDA runtime application programming interface.
 
 .. autofunction:: cuda.cudart.cudaDeviceReset
@@ -133,8 +135,6 @@ Some functions have overloaded C++ API template versions documented separately i
 .. autofunction:: cuda.cudart.cudaFuncSetSharedMemConfig
 .. autofunction:: cuda.cudart.cudaFuncGetAttributes
 .. autofunction:: cuda.cudart.cudaFuncSetAttribute
-.. autofunction:: cuda.cudart.cudaSetDoubleForDevice
-.. autofunction:: cuda.cudart.cudaSetDoubleForHost
 .. autofunction:: cuda.cudart.cudaLaunchHostFunc
 
 Occupancy
@@ -469,6 +469,7 @@ Version Management
 
 .. autofunction:: cuda.cudart.cudaDriverGetVersion
 .. autofunction:: cuda.cudart.cudaRuntimeGetVersion
+.. autofunction:: cuda.cudart.getLocalRuntimeVersion
 
 Graph Management
 ----------------
@@ -568,6 +569,8 @@ impl_private
 
 
 
+
+
 This section describes the C++ high level API functions of the CUDA runtime application programming interface. To use these functions, your application needs to be compiled with the ``nvcc``\  compiler.
 
 
@@ -752,19 +755,13 @@ Data types used by CUDA Runtime
 .. autoclass:: cuda.cudart.cudaExternalMemoryBufferDesc
 .. autoclass:: cuda.cudart.cudaExternalMemoryMipmappedArrayDesc
 .. autoclass:: cuda.cudart.cudaExternalSemaphoreHandleDesc
-.. autoclass:: cuda.cudart.cudaExternalSemaphoreSignalParams_v1
-.. autoclass:: cuda.cudart.cudaExternalSemaphoreWaitParams_v1
 .. autoclass:: cuda.cudart.cudaExternalSemaphoreSignalParams
 .. autoclass:: cuda.cudart.cudaExternalSemaphoreWaitParams
-.. autoclass:: cuda.cudart.cudaLaunchParams
 .. autoclass:: cuda.cudart.cudaKernelNodeParams
 .. autoclass:: cuda.cudart.cudaExternalSemaphoreSignalNodeParams
 .. autoclass:: cuda.cudart.cudaExternalSemaphoreWaitNodeParams
 .. autoclass:: cuda.cudart.cudaLaunchAttributeValue
 .. autoclass:: cuda.cudart.cudaLaunchAttribute_st
-.. autoclass:: cuda.cudart.cudaLaunchConfig_st
-.. autoclass:: cuda.cudart.surfaceReference
-.. autoclass:: cuda.cudart.textureReference
 .. autoclass:: cuda.cudart.cudaTextureDesc
 .. autoclass:: cuda.cudart.cudaTextureDesc_v2
 .. autoclass:: cuda.cudart.cudaEglFrameType
@@ -4546,7 +4543,6 @@ Data types used by CUDA Runtime
 .. autoclass:: cuda.cudart.cudaGraphExec_t
 .. autoclass:: cuda.cudart.cudaLaunchAttributeValue
 .. autoclass:: cuda.cudart.cudaLaunchAttribute
-.. autoclass:: cuda.cudart.cudaLaunchConfig_t
 .. autoclass:: cuda.cudart.cudaSurfaceObject_t
 .. autoclass:: cuda.cudart.cudaTextureObject_t
 .. autoattribute:: cuda.cudart.CUDA_EGL_MAX_PLANES
diff --git a/docs_src/source/module/driver.rst b/docs_src/source/module/driver.rst
new file mode 100644
index 00000000..c04fb5b8
--- /dev/null
+++ b/docs_src/source/module/driver.rst
@@ -0,0 +1,5819 @@
+------
+driver
+------
+
+Data types used by CUDA driver
+------------------------------
+
+
+
+.. autoclass:: cuda.bindings.driver.CUuuid_st
+.. autoclass:: cuda.bindings.driver.CUipcEventHandle_st
+.. autoclass:: cuda.bindings.driver.CUipcMemHandle_st
+.. autoclass:: cuda.bindings.driver.CUstreamBatchMemOpParams_union
+.. autoclass:: cuda.bindings.driver.CUDA_BATCH_MEM_OP_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUdevprop_st
+.. autoclass:: cuda.bindings.driver.CUaccessPolicyWindow_st
+.. autoclass:: cuda.bindings.driver.CUDA_KERNEL_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_MEMSET_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_HOST_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUlaunchAttributeValue_union
+.. autoclass:: cuda.bindings.driver.CUlaunchAttribute_st
+.. autoclass:: cuda.bindings.driver.CUlaunchConfig_st
+.. autoclass:: cuda.bindings.driver.CUexecAffinitySmCount_st
+.. autoclass:: cuda.bindings.driver.CUexecAffinityParam_st
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY2D_st
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_st
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_PEER_st
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_DESCRIPTOR_st
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY3D_DESCRIPTOR_st
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_SPARSE_PROPERTIES_st
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_MEMORY_REQUIREMENTS_st
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_TEXTURE_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_VIEW_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_st
+.. autoclass:: cuda.bindings.driver.CUDA_LAUNCH_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUarrayMapInfo_st
+.. autoclass:: cuda.bindings.driver.CUmemLocation_st
+.. autoclass:: cuda.bindings.driver.CUmemAllocationProp_st
+.. autoclass:: cuda.bindings.driver.CUmemAccessDesc_st
+.. autoclass:: cuda.bindings.driver.CUmemPoolProps_st
+.. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData_st
+.. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS_st
+.. autoclass:: cuda.bindings.driver.CUeglFrame_st
+.. autoclass:: cuda.bindings.driver.CUipcMem_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUipcMem_flags.CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS
+
+
+        Automatically enable peer access between remote devices as needed
+
+.. autoclass:: cuda.bindings.driver.CUmemAttach_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAttach_flags.CU_MEM_ATTACH_GLOBAL
+
+
+        Memory can be accessed by any stream on any device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAttach_flags.CU_MEM_ATTACH_HOST
+
+
+        Memory cannot be accessed by any stream on any device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAttach_flags.CU_MEM_ATTACH_SINGLE
+
+
+        Memory can only be accessed by a single stream on the associated device
+
+.. autoclass:: cuda.bindings.driver.CUctx_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_SCHED_AUTO
+
+
+        Automatic scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_SCHED_SPIN
+
+
+        Set spin as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_SCHED_YIELD
+
+
+        Set yield as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_SCHED_BLOCKING_SYNC
+
+
+        Set blocking synchronization as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_BLOCKING_SYNC
+
+
+        Set blocking synchronization as default scheduling [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_SCHED_MASK
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_MAP_HOST
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_LMEM_RESIZE_TO_MAX
+
+
+        Keep local memory allocation after launch
+
+
+    .. autoattribute:: cuda.bindings.driver.CUctx_flags.CU_CTX_FLAGS_MASK
+
+.. autoclass:: cuda.bindings.driver.CUevent_sched_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_sched_flags.CU_EVENT_SCHED_AUTO
+
+
+        Automatic scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_sched_flags.CU_EVENT_SCHED_SPIN
+
+
+        Set spin as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_sched_flags.CU_EVENT_SCHED_YIELD
+
+
+        Set yield as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_sched_flags.CU_EVENT_SCHED_BLOCKING_SYNC
+
+
+        Set blocking synchronization as default scheduling
+
+.. autoclass:: cuda.bindings.driver.cl_event_flags
+
+    .. autoattribute:: cuda.bindings.driver.cl_event_flags.NVCL_EVENT_SCHED_AUTO
+
+
+        Automatic scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_event_flags.NVCL_EVENT_SCHED_SPIN
+
+
+        Set spin as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_event_flags.NVCL_EVENT_SCHED_YIELD
+
+
+        Set yield as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_event_flags.NVCL_EVENT_SCHED_BLOCKING_SYNC
+
+
+        Set blocking synchronization as default scheduling
+
+.. autoclass:: cuda.bindings.driver.cl_context_flags
+
+    .. autoattribute:: cuda.bindings.driver.cl_context_flags.NVCL_CTX_SCHED_AUTO
+
+
+        Automatic scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_context_flags.NVCL_CTX_SCHED_SPIN
+
+
+        Set spin as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_context_flags.NVCL_CTX_SCHED_YIELD
+
+
+        Set yield as default scheduling
+
+
+    .. autoattribute:: cuda.bindings.driver.cl_context_flags.NVCL_CTX_SCHED_BLOCKING_SYNC
+
+
+        Set blocking synchronization as default scheduling
+
+.. autoclass:: cuda.bindings.driver.CUstream_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUstream_flags.CU_STREAM_DEFAULT
+
+
+        Default stream flag
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstream_flags.CU_STREAM_NON_BLOCKING
+
+
+        Stream does not synchronize with stream 0 (the NULL stream)
+
+.. autoclass:: cuda.bindings.driver.CUevent_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_flags.CU_EVENT_DEFAULT
+
+
+        Default event flag
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_flags.CU_EVENT_BLOCKING_SYNC
+
+
+        Event uses blocking synchronization
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_flags.CU_EVENT_DISABLE_TIMING
+
+
+        Event will not record timing data
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_flags.CU_EVENT_INTERPROCESS
+
+
+        Event is suitable for interprocess use. CU_EVENT_DISABLE_TIMING must be set
+
+.. autoclass:: cuda.bindings.driver.CUevent_record_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_record_flags.CU_EVENT_RECORD_DEFAULT
+
+
+        Default event record flag
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_record_flags.CU_EVENT_RECORD_EXTERNAL
+
+
+        When using stream capture, create an event record node instead of the default behavior. This flag is invalid when used outside of capture.
+
+.. autoclass:: cuda.bindings.driver.CUevent_wait_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_wait_flags.CU_EVENT_WAIT_DEFAULT
+
+
+        Default event wait flag
+
+
+    .. autoattribute:: cuda.bindings.driver.CUevent_wait_flags.CU_EVENT_WAIT_EXTERNAL
+
+
+        When using stream capture, create an event wait node instead of the default behavior. This flag is invalid when used outside of capture.
+
+.. autoclass:: cuda.bindings.driver.CUstreamWaitValue_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWaitValue_flags.CU_STREAM_WAIT_VALUE_GEQ
+
+
+        Wait until (int32_t)(*addr - value) >= 0 (or int64_t for 64 bit values). Note this is a cyclic comparison which ignores wraparound. (Default behavior.)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWaitValue_flags.CU_STREAM_WAIT_VALUE_EQ
+
+
+        Wait until *addr == value.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWaitValue_flags.CU_STREAM_WAIT_VALUE_AND
+
+
+        Wait until (*addr & value) != 0.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWaitValue_flags.CU_STREAM_WAIT_VALUE_NOR
+
+
+        Wait until ~(*addr | value) != 0. Support for this operation can be queried with :py:obj:`~.cuDeviceGetAttribute()` and :py:obj:`~.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWaitValue_flags.CU_STREAM_WAIT_VALUE_FLUSH
+
+
+        Follow the wait operation with a flush of outstanding remote writes. This means that, if a remote write operation is guaranteed to have reached the device before the wait can be satisfied, that write is guaranteed to be visible to downstream device work. The device is permitted to reorder remote writes internally. For example, this flag would be required if two remote writes arrive in a defined order, the wait is satisfied by the second write, and downstream work needs to observe the first write. Support for this operation is restricted to selected platforms and can be queried with :py:obj:`~.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES`.
+
+.. autoclass:: cuda.bindings.driver.CUstreamWriteValue_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWriteValue_flags.CU_STREAM_WRITE_VALUE_DEFAULT
+
+
+        Default behavior
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamWriteValue_flags.CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER
+
+
+        Permits the write to be reordered with writes which were issued before it, as a performance optimization. Normally, :py:obj:`~.cuStreamWriteValue32` will provide a memory fence before the write, which has similar semantics to __threadfence_system() but is scoped to the stream rather than a CUDA thread. This flag is not supported in the v2 API.
+
+.. autoclass:: cuda.bindings.driver.CUstreamBatchMemOpType
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_WAIT_VALUE_32
+
+
+        Represents a :py:obj:`~.cuStreamWaitValue32` operation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_WRITE_VALUE_32
+
+
+        Represents a :py:obj:`~.cuStreamWriteValue32` operation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_WAIT_VALUE_64
+
+
+        Represents a :py:obj:`~.cuStreamWaitValue64` operation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_WRITE_VALUE_64
+
+
+        Represents a :py:obj:`~.cuStreamWriteValue64` operation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_BARRIER
+
+
+        Insert a memory barrier of the specified type
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamBatchMemOpType.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES
+
+
+        This has the same effect as :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH`, but as a standalone operation.
+
+.. autoclass:: cuda.bindings.driver.CUstreamMemoryBarrier_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamMemoryBarrier_flags.CU_STREAM_MEMORY_BARRIER_TYPE_SYS
+
+
+        System-wide memory barrier.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamMemoryBarrier_flags.CU_STREAM_MEMORY_BARRIER_TYPE_GPU
+
+
+        Limit memory barrier scope to the GPU.
+
+.. autoclass:: cuda.bindings.driver.CUoccupancy_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUoccupancy_flags.CU_OCCUPANCY_DEFAULT
+
+
+        Default behavior
+
+
+    .. autoattribute:: cuda.bindings.driver.CUoccupancy_flags.CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE
+
+
+        Assume global caching is enabled and cannot be automatically turned off
+
+.. autoclass:: cuda.bindings.driver.CUstreamUpdateCaptureDependencies_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamUpdateCaptureDependencies_flags.CU_STREAM_ADD_CAPTURE_DEPENDENCIES
+
+
+        Add new nodes to the dependency set
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamUpdateCaptureDependencies_flags.CU_STREAM_SET_CAPTURE_DEPENDENCIES
+
+
+        Replace the dependency set with the new nodes
+
+.. autoclass:: cuda.bindings.driver.CUarray_format
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNSIGNED_INT8
+
+
+        Unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNSIGNED_INT16
+
+
+        Unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNSIGNED_INT32
+
+
+        Unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SIGNED_INT8
+
+
+        Signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SIGNED_INT16
+
+
+        Signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SIGNED_INT32
+
+
+        Signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_HALF
+
+
+        16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_FLOAT
+
+
+        32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_NV12
+
+
+        8-bit YUV planar format, with 4:2:0 sampling
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT8X1
+
+
+        1 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT8X2
+
+
+        2 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT8X4
+
+
+        4 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT16X1
+
+
+        1 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT16X2
+
+
+        2 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_UNORM_INT16X4
+
+
+        4 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT8X1
+
+
+        1 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT8X2
+
+
+        2 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT8X4
+
+
+        4 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT16X1
+
+
+        1 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT16X2
+
+
+        2 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_SNORM_INT16X4
+
+
+        4 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC1_UNORM
+
+
+        4 channel unsigned normalized block-compressed (BC1 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC1_UNORM_SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC1 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC2_UNORM
+
+
+        4 channel unsigned normalized block-compressed (BC2 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC2_UNORM_SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC2 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC3_UNORM
+
+
+        4 channel unsigned normalized block-compressed (BC3 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC3_UNORM_SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC3 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC4_UNORM
+
+
+        1 channel unsigned normalized block-compressed (BC4 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC4_SNORM
+
+
+        1 channel signed normalized block-compressed (BC4 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC5_UNORM
+
+
+        2 channel unsigned normalized block-compressed (BC5 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC5_SNORM
+
+
+        2 channel signed normalized block-compressed (BC5 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC6H_UF16
+
+
+        3 channel unsigned half-float block-compressed (BC6H compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC6H_SF16
+
+
+        3 channel signed half-float block-compressed (BC6H compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC7_UNORM
+
+
+        4 channel unsigned normalized block-compressed (BC7 compression) format
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_format.CU_AD_FORMAT_BC7_UNORM_SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC7 compression) format with sRGB encoding
+
+.. autoclass:: cuda.bindings.driver.CUaddress_mode
+
+    .. autoattribute:: cuda.bindings.driver.CUaddress_mode.CU_TR_ADDRESS_MODE_WRAP
+
+
+        Wrapping address mode
+
+
+    .. autoattribute:: cuda.bindings.driver.CUaddress_mode.CU_TR_ADDRESS_MODE_CLAMP
+
+
+        Clamp to edge address mode
+
+
+    .. autoattribute:: cuda.bindings.driver.CUaddress_mode.CU_TR_ADDRESS_MODE_MIRROR
+
+
+        Mirror address mode
+
+
+    .. autoattribute:: cuda.bindings.driver.CUaddress_mode.CU_TR_ADDRESS_MODE_BORDER
+
+
+        Border address mode
+
+.. autoclass:: cuda.bindings.driver.CUfilter_mode
+
+    .. autoattribute:: cuda.bindings.driver.CUfilter_mode.CU_TR_FILTER_MODE_POINT
+
+
+        Point filter mode
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfilter_mode.CU_TR_FILTER_MODE_LINEAR
+
+
+        Linear filter mode
+
+.. autoclass:: cuda.bindings.driver.CUdevice_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK
+
+
+        Maximum number of threads per block
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X
+
+
+        Maximum block dimension X
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y
+
+
+        Maximum block dimension Y
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z
+
+
+        Maximum block dimension Z
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X
+
+
+        Maximum grid dimension X
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y
+
+
+        Maximum grid dimension Y
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z
+
+
+        Maximum grid dimension Z
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
+
+
+        Maximum shared memory available per block in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK
+
+
+        Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY
+
+
+        Memory available on device for constant variables in a CUDA C kernel in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_WARP_SIZE
+
+
+        Warp size in threads
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_PITCH
+
+
+        Maximum pitch in bytes allowed by memory copies
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK
+
+
+        Maximum number of 32-bit registers available per block
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK
+
+
+        Deprecated, use CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CLOCK_RATE
+
+
+        Typical clock frequency in kilohertz
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT
+
+
+        Alignment requirement for textures
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_OVERLAP
+
+
+        Device can possibly copy memory and execute a kernel concurrently. Deprecated. Use instead CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT
+
+
+        Number of multiprocessors on device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT
+
+
+        Specifies whether there is a run time limit on kernels
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_INTEGRATED
+
+
+        Device is integrated with host memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY
+
+
+        Device can map host memory into CUDA address space
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COMPUTE_MODE
+
+
+        Compute mode (See :py:obj:`~.CUcomputemode` for details)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH
+
+
+        Maximum 1D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH
+
+
+        Maximum 2D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT
+
+
+        Maximum 2D texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH
+
+
+        Maximum 3D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT
+
+
+        Maximum 3D texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH
+
+
+        Maximum 3D texture depth
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
+
+
+        Maximum 2D layered texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
+
+
+        Maximum 2D layered texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
+
+
+        Maximum layers in a 2D layered texture
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH
+
+
+        Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT
+
+
+        Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES
+
+
+        Deprecated, use CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT
+
+
+        Alignment requirement for surfaces
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS
+
+
+        Device can possibly execute multiple kernels concurrently
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_ECC_ENABLED
+
+
+        Device has ECC support enabled
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_PCI_BUS_ID
+
+
+        PCI bus ID of the device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID
+
+
+        PCI device ID of the device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_TCC_DRIVER
+
+
+        Device is using TCC driver model
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE
+
+
+        Peak memory clock frequency in kilohertz
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH
+
+
+        Global memory bus width in bits
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE
+
+
+        Size of L2 cache in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR
+
+
+        Maximum resident threads per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT
+
+
+        Number of asynchronous engines
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING
+
+
+        Device shares a unified address space with the host
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH
+
+
+        Maximum 1D layered texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS
+
+
+        Maximum layers in a 1D layered texture
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER
+
+
+        Deprecated, do not use.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH
+
+
+        Maximum 2D texture width if CUDA_ARRAY3D_TEXTURE_GATHER is set
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT
+
+
+        Maximum 2D texture height if CUDA_ARRAY3D_TEXTURE_GATHER is set
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE
+
+
+        Alternate maximum 3D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE
+
+
+        Alternate maximum 3D texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE
+
+
+        Alternate maximum 3D texture depth
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID
+
+
+        PCI domain ID of the device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT
+
+
+        Pitch alignment requirement for textures
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH
+
+
+        Maximum cubemap texture width/height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH
+
+
+        Maximum cubemap layered texture width/height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS
+
+
+        Maximum layers in a cubemap layered texture
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH
+
+
+        Maximum 1D surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH
+
+
+        Maximum 2D surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT
+
+
+        Maximum 2D surface height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH
+
+
+        Maximum 3D surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT
+
+
+        Maximum 3D surface height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH
+
+
+        Maximum 3D surface depth
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH
+
+
+        Maximum 1D layered surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS
+
+
+        Maximum layers in a 1D layered surface
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH
+
+
+        Maximum 2D layered surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT
+
+
+        Maximum 2D layered surface height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS
+
+
+        Maximum layers in a 2D layered surface
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH
+
+
+        Maximum cubemap surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH
+
+
+        Maximum cubemap layered surface width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS
+
+
+        Maximum layers in a cubemap layered surface
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH
+
+
+        Deprecated, do not use. Use cudaDeviceGetTexture1DLinearMaxWidth() or :py:obj:`~.cuDeviceGetTexture1DLinearMaxWidth()` instead.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH
+
+
+        Maximum 2D linear texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT
+
+
+        Maximum 2D linear texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH
+
+
+        Maximum 2D linear texture pitch in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH
+
+
+        Maximum mipmapped 2D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT
+
+
+        Maximum mipmapped 2D texture height
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR
+
+
+        Major compute capability version number
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR
+
+
+        Minor compute capability version number
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH
+
+
+        Maximum mipmapped 1D texture width
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED
+
+
+        Device supports stream priorities
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED
+
+
+        Device supports caching globals in L1
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED
+
+
+        Device supports caching locals in L1
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR
+
+
+        Maximum shared memory available per multiprocessor in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR
+
+
+        Maximum number of 32-bit registers available per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY
+
+
+        Device can allocate managed memory on this system
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD
+
+
+        Device is on a multi-GPU board
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID
+
+
+        Unique id for a group of devices on the same multi-GPU board
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED
+
+
+        Link between the device and the host supports native atomic operations (this is a placeholder attribute, and is not supported on any current hardware)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO
+
+
+        Ratio of single precision performance (in floating-point operations per second) to double precision performance
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS
+
+
+        Device supports coherently accessing pageable memory without calling cudaHostRegister on it
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS
+
+
+        Device can coherently access managed memory concurrently with the CPU
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED
+
+
+        Device supports compute preemption.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM
+
+
+        Device can access host registered memory at the same virtual address as the CPU
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS
+
+
+        :py:obj:`~.cuStreamBatchMemOp` and related APIs are supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS
+
+
+        64-bit operations are supported in :py:obj:`~.cuStreamBatchMemOp` and related APIs.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR
+
+
+        :py:obj:`~.CU_STREAM_WAIT_VALUE_NOR` is supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH
+
+
+        Device supports launching cooperative kernels via :py:obj:`~.cuLaunchCooperativeKernel`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH
+
+
+        Deprecated, :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` is deprecated.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN
+
+
+        Maximum optin shared memory per block
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES
+
+
+        The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported on the device. See :py:obj:`~.Stream Memory Operations` for additional details.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED
+
+
+        Device supports host memory registration via :py:obj:`~.cudaHostRegister`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES
+
+
+        Device accesses pageable memory via the host's page tables.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST
+
+
+        The host can directly access managed memory on the device without migration.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED
+
+
+        Deprecated, Use CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_VIRTUAL_MEMORY_MANAGEMENT_SUPPORTED
+
+
+        Device supports virtual memory management APIs like :py:obj:`~.cuMemAddressReserve`, :py:obj:`~.cuMemCreate`, :py:obj:`~.cuMemMap` and related APIs
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED
+
+
+        Device supports exporting memory to a posix file descriptor with :py:obj:`~.cuMemExportToShareableHandle`, if requested via :py:obj:`~.cuMemCreate`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED
+
+
+        Device supports exporting memory to a Win32 NT handle with :py:obj:`~.cuMemExportToShareableHandle`, if requested via :py:obj:`~.cuMemCreate`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED
+
+
+        Device supports exporting memory to a Win32 KMT handle with :py:obj:`~.cuMemExportToShareableHandle`, if requested via :py:obj:`~.cuMemCreate`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_BLOCKS_PER_MULTIPROCESSOR
+
+
+        Maximum number of blocks per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GENERIC_COMPRESSION_SUPPORTED
+
+
+        Device supports compression of memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_PERSISTING_L2_CACHE_SIZE
+
+
+        Maximum L2 persisting lines capacity setting in bytes.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX_ACCESS_POLICY_WINDOW_SIZE
+
+
+        Maximum value of :py:obj:`~.CUaccessPolicyWindow.num_bytes`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WITH_CUDA_VMM_SUPPORTED
+
+
+        Device supports specifying the GPUDirect RDMA flag with :py:obj:`~.cuMemCreate`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_RESERVED_SHARED_MEMORY_PER_BLOCK
+
+
+        Shared memory reserved by CUDA driver per block in bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_SPARSE_CUDA_ARRAY_SUPPORTED
+
+
+        Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED
+
+
+        Device supports using the :py:obj:`~.cuMemHostRegister` flag :py:obj:`~.CU_MEMHOSTERGISTER_READ_ONLY` to register memory that must be mapped as read-only to the GPU
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_TIMELINE_SEMAPHORE_INTEROP_SUPPORTED
+
+
+        External timeline semaphore interop is supported on the device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED
+
+
+        Device supports using the :py:obj:`~.cuMemAllocAsync` and :py:obj:`~.cuMemPool` family of APIs
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_SUPPORTED
+
+
+        Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see https://docs.nvidia.com/cuda/gpudirect-rdma for more information)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_FLUSH_WRITES_OPTIONS
+
+
+        The returned attribute shall be interpreted as a bitmask, where the individual bits are described by the :py:obj:`~.CUflushGPUDirectRDMAWritesOptions` enum
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_GPU_DIRECT_RDMA_WRITES_ORDERING
+
+
+        GPUDirect RDMA writes to the device do not need to be flushed for consumers within the scope indicated by the returned attribute. See :py:obj:`~.CUGPUDirectRDMAWritesOrdering` for the numerical values returned here.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MEMPOOL_SUPPORTED_HANDLE_TYPES
+
+
+        Handle types supported with mempool based IPC
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CLUSTER_LAUNCH
+
+
+        Indicates device supports cluster launch
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_DEFERRED_MAPPING_CUDA_ARRAY_SUPPORTED
+
+
+        Device supports deferred mapping CUDA arrays and CUDA mipmapped arrays
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2
+
+
+        64-bit operations are supported in :py:obj:`~.cuStreamBatchMemOp_v2` and related v2 MemOp APIs.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2
+
+
+        :py:obj:`~.CU_STREAM_WAIT_VALUE_NOR` is supported by v2 MemOp APIs.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_DMA_BUF_SUPPORTED
+
+
+        Device supports buffer sharing with dma_buf mechanism.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUpointer_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_CONTEXT
+
+
+        The :py:obj:`~.CUcontext` on which a pointer was allocated or registered
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MEMORY_TYPE
+
+
+        The :py:obj:`~.CUmemorytype` describing the physical location of a pointer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_DEVICE_POINTER
+
+
+        The address at which a pointer's memory may be accessed on the device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_HOST_POINTER
+
+
+        The address at which a pointer's memory may be accessed on the host
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_P2P_TOKENS
+
+
+        A pair of tokens for use with the nv-p2p.h Linux kernel interface
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_SYNC_MEMOPS
+
+
+        Synchronize every synchronous memory operation initiated on this region
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_BUFFER_ID
+
+
+        A process-wide unique ID for an allocated memory region
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_IS_MANAGED
+
+
+        Indicates if the pointer points to managed memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
+
+
+        A device ordinal of a device on which a pointer was allocated or registered
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE
+
+
+        1 if this pointer maps to an allocation that is suitable for :py:obj:`~.cudaIpcGetMemHandle`, 0 otherwise
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_RANGE_START_ADDR
+
+
+        Starting address for this requested pointer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_RANGE_SIZE
+
+
+        Size of the address range for this requested pointer
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MAPPED
+
+
+        1 if this pointer is in a valid address range that is mapped to a backing allocation, 0 otherwise
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES
+
+
+        Bitmask of allowed :py:obj:`~.CUmemAllocationHandleType` for this allocation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_IS_GPU_DIRECT_RDMA_CAPABLE
+
+
+        1 if the memory this pointer is referencing can be used with the GPUDirect RDMA API
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_ACCESS_FLAGS
+
+
+        Returns the access flags the device associated with the current context has on the corresponding memory referenced by the pointer given
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MEMPOOL_HANDLE
+
+
+        Returns the mempool handle for the allocation if it was allocated from a mempool. Otherwise returns NULL.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MAPPING_SIZE
+
+
+        Size of the actual underlying mapping that the pointer belongs to
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MAPPING_BASE_ADDR
+
+
+        The start address of the mapping that the pointer belongs to
+
+
+    .. autoattribute:: cuda.bindings.driver.CUpointer_attribute.CU_POINTER_ATTRIBUTE_MEMORY_BLOCK_ID
+
+
+        A process-wide unique id corresponding to the physical allocation the pointer belongs to
+
+.. autoclass:: cuda.bindings.driver.CUfunction_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK
+
+
+        The maximum number of threads per block, beyond which a launch of the function would fail. This number depends on both the function and the device on which the function is currently loaded.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES
+
+
+        The size in bytes of statically-allocated shared memory required by this function. This does not include dynamically-allocated shared memory requested by the user at runtime.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES
+
+
+        The size in bytes of user-allocated constant memory required by this function.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES
+
+
+        The size in bytes of local memory used by each thread of this function.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_NUM_REGS
+
+
+        The number of registers used by each thread of this function.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_PTX_VERSION
+
+
+        The PTX virtual architecture version for which the function was compiled. This value is the major PTX version * 10 + the minor PTX version, so a PTX version 1.3 function would return the value 13. Note that this may return the undefined value of 0 for cubins compiled prior to CUDA 3.0.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_BINARY_VERSION
+
+
+        The binary architecture version for which the function was compiled. This value is the major binary version * 10 + the minor binary version, so a binary version 1.3 function would return the value 13. Note that this will return a value of 10 for legacy cubins that do not have a properly-encoded binary architecture version.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_CACHE_MODE_CA
+
+
+        The attribute to indicate whether the function has been compiled with user specified option "-Xptxas --dlcm=ca" set .
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES
+
+
+        The maximum size in bytes of dynamically-allocated shared memory that can be used by this function. If the user-specified dynamic shared memory size is larger than this value, the launch will fail. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT
+
+
+        On devices where the L1 cache and shared memory use the same hardware resources, this sets the shared memory carveout preference, in percent of the total shared memory. Refer to :py:obj:`~.CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR`. This is only a hint, and the driver can choose a different ratio if required to execute the function. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_CLUSTER_SIZE_MUST_BE_SET
+
+
+        If this attribute is set, the kernel must launch with a valid cluster size specified. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_WIDTH
+
+
+        The required cluster width in blocks. The values must either all be 0 or all be positive. The validity of the cluster dimensions is otherwise checked at launch time.
+
+
+
+        If the value is set during compile time, it cannot be set at runtime. Setting it at runtime will return CUDA_ERROR_NOT_PERMITTED. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_HEIGHT
+
+
+        The required cluster height in blocks. The values must either all be 0 or all be positive. The validity of the cluster dimensions is otherwise checked at launch time.
+
+
+
+        If the value is set during compile time, it cannot be set at runtime. Setting it at runtime should return CUDA_ERROR_NOT_PERMITTED. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_REQUIRED_CLUSTER_DEPTH
+
+
+        The required cluster depth in blocks. The values must either all be 0 or all be positive. The validity of the cluster dimensions is otherwise checked at launch time.
+
+
+
+        If the value is set during compile time, it cannot be set at runtime. Setting it at runtime should return CUDA_ERROR_NOT_PERMITTED. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_NON_PORTABLE_CLUSTER_SIZE_ALLOWED
+
+
+        Whether the function can be launched with non-portable cluster size. 1 is allowed, 0 is disallowed. A non-portable cluster size may only function on the specific SKUs the program is tested on. The launch might fail if the program is run on a different hardware platform.
+
+
+
+        CUDA API provides cudaOccupancyMaxActiveClusters to assist with checking whether the desired size can be launched on the current device.
+
+
+
+        Portable Cluster Size
+
+
+
+        A portable cluster size is guaranteed to be functional on all compute capabilities higher than the target compute capability. The portable cluster size for sm_90 is 8 blocks per cluster. This value may increase for future compute capabilities.
+
+
+
+        The specific hardware unit may support higher cluster sizes that’s not guaranteed to be portable. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
+
+
+        The block scheduling policy of a function. The value type is CUclusterSchedulingPolicy / cudaClusterSchedulingPolicy. See :py:obj:`~.cuFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunction_attribute.CU_FUNC_ATTRIBUTE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUfunc_cache
+
+    .. autoattribute:: cuda.bindings.driver.CUfunc_cache.CU_FUNC_CACHE_PREFER_NONE
+
+
+        no preference for shared memory or L1 (default)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunc_cache.CU_FUNC_CACHE_PREFER_SHARED
+
+
+        prefer larger shared memory and smaller L1 cache
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunc_cache.CU_FUNC_CACHE_PREFER_L1
+
+
+        prefer larger L1 cache and smaller shared memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUfunc_cache.CU_FUNC_CACHE_PREFER_EQUAL
+
+
+        prefer equal sized L1 cache and shared memory
+
+.. autoclass:: cuda.bindings.driver.CUsharedconfig
+
+    .. autoattribute:: cuda.bindings.driver.CUsharedconfig.CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE
+
+
+        set default shared memory bank size
+
+
+    .. autoattribute:: cuda.bindings.driver.CUsharedconfig.CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE
+
+
+        set shared memory bank width to four bytes
+
+
+    .. autoattribute:: cuda.bindings.driver.CUsharedconfig.CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE
+
+
+        set shared memory bank width to eight bytes
+
+.. autoclass:: cuda.bindings.driver.CUshared_carveout
+
+    .. autoattribute:: cuda.bindings.driver.CUshared_carveout.CU_SHAREDMEM_CARVEOUT_DEFAULT
+
+
+        No preference for shared memory or L1 (default)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUshared_carveout.CU_SHAREDMEM_CARVEOUT_MAX_SHARED
+
+
+        Prefer maximum available shared memory, minimum L1 cache
+
+
+    .. autoattribute:: cuda.bindings.driver.CUshared_carveout.CU_SHAREDMEM_CARVEOUT_MAX_L1
+
+
+        Prefer maximum available L1 cache, minimum shared memory
+
+.. autoclass:: cuda.bindings.driver.CUmemorytype
+
+    .. autoattribute:: cuda.bindings.driver.CUmemorytype.CU_MEMORYTYPE_HOST
+
+
+        Host memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemorytype.CU_MEMORYTYPE_DEVICE
+
+
+        Device memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemorytype.CU_MEMORYTYPE_ARRAY
+
+
+        Array memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemorytype.CU_MEMORYTYPE_UNIFIED
+
+
+        Unified device or host memory
+
+.. autoclass:: cuda.bindings.driver.CUcomputemode
+
+    .. autoattribute:: cuda.bindings.driver.CUcomputemode.CU_COMPUTEMODE_DEFAULT
+
+
+        Default compute mode (Multiple contexts allowed per device)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUcomputemode.CU_COMPUTEMODE_PROHIBITED
+
+
+        Compute-prohibited mode (No contexts can be created on this device at this time)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUcomputemode.CU_COMPUTEMODE_EXCLUSIVE_PROCESS
+
+
+        Compute-exclusive-process mode (Only one context used by a single process can be present on this device at a time)
+
+.. autoclass:: cuda.bindings.driver.CUmem_advise
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_SET_READ_MOSTLY
+
+
+        Data will mostly be read and only occassionally be written to
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_UNSET_READ_MOSTLY
+
+
+        Undo the effect of :py:obj:`~.CU_MEM_ADVISE_SET_READ_MOSTLY`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_SET_PREFERRED_LOCATION
+
+
+        Set the preferred location for the data as the specified device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION
+
+
+        Clear the preferred location for the data
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_SET_ACCESSED_BY
+
+
+        Data will be accessed by the specified device, so prevent page faults as much as possible
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_advise.CU_MEM_ADVISE_UNSET_ACCESSED_BY
+
+
+        Let the Unified Memory subsystem decide on the page faulting policy for the specified device
+
+.. autoclass:: cuda.bindings.driver.CUmem_range_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_range_attribute.CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY
+
+
+        Whether the range will mostly be read and only occassionally be written to
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_range_attribute.CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION
+
+
+        The preferred location of the range
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_range_attribute.CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY
+
+
+        Memory range has :py:obj:`~.CU_MEM_ADVISE_SET_ACCESSED_BY` set for specified device
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmem_range_attribute.CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION
+
+
+        The last location to which the range was prefetched
+
+.. autoclass:: cuda.bindings.driver.CUjit_option
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_MAX_REGISTERS
+
+
+        Max number of registers that a thread may use.
+
+        Option type: unsigned int
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_THREADS_PER_BLOCK
+
+
+        IN: Specifies minimum number of threads per block to target compilation for
+
+        OUT: Returns the number of threads the compiler actually targeted. This restricts the resource utilization fo the compiler (e.g. max registers) such that a block with the given number of threads should be able to launch based on register limitations. Note, this option does not currently take into account any other resource limitations, such as shared memory utilization.
+
+        Cannot be combined with :py:obj:`~.CU_JIT_TARGET`.
+
+        Option type: unsigned int
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_WALL_TIME
+
+
+        Overwrites the option value with the total wall clock time, in milliseconds, spent in the compiler and linker
+
+        Option type: float
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_INFO_LOG_BUFFER
+
+
+        Pointer to a buffer in which to print any log messages that are informational in nature (the buffer size is specified via option :py:obj:`~.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES`)
+
+        Option type: char *
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES
+
+
+        IN: Log buffer size in bytes. Log messages will be capped at this size (including null terminator)
+
+        OUT: Amount of log buffer filled with messages
+
+        Option type: unsigned int
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_ERROR_LOG_BUFFER
+
+
+        Pointer to a buffer in which to print any log messages that reflect errors (the buffer size is specified via option :py:obj:`~.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES`)
+
+        Option type: char *
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES
+
+
+        IN: Log buffer size in bytes. Log messages will be capped at this size (including null terminator)
+
+        OUT: Amount of log buffer filled with messages
+
+        Option type: unsigned int
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_OPTIMIZATION_LEVEL
+
+
+        Level of optimizations to apply to generated code (0 - 4), with 4 being the default and highest level of optimizations.
+
+        Option type: unsigned int
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_TARGET_FROM_CUCONTEXT
+
+
+        No option value required. Determines the target based on the current attached context (default)
+
+        Option type: No option value needed
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_TARGET
+
+
+        Target is chosen based on supplied :py:obj:`~.CUjit_target`. Cannot be combined with :py:obj:`~.CU_JIT_THREADS_PER_BLOCK`.
+
+        Option type: unsigned int for enumerated type :py:obj:`~.CUjit_target`
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_FALLBACK_STRATEGY
+
+
+        Specifies choice of fallback strategy if matching cubin is not found. Choice is based on supplied :py:obj:`~.CUjit_fallback`. This option cannot be used with cuLink* APIs as the linker requires exact matches.
+
+        Option type: unsigned int for enumerated type :py:obj:`~.CUjit_fallback`
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_GENERATE_DEBUG_INFO
+
+
+        Specifies whether to create debug information in output (-g) (0: false, default)
+
+        Option type: int
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_LOG_VERBOSE
+
+
+        Generate verbose log messages (0: false, default)
+
+        Option type: int
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_GENERATE_LINE_INFO
+
+
+        Generate line number information (-lineinfo) (0: false, default)
+
+        Option type: int
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_CACHE_MODE
+
+
+        Specifies whether to enable caching explicitly (-dlcm) 
+
+        Choice is based on supplied :py:obj:`~.CUjit_cacheMode_enum`.
+
+        Option type: unsigned int for enumerated type :py:obj:`~.CUjit_cacheMode_enum`
+
+        Applies to: compiler only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_NEW_SM3X_OPT
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_FAST_COMPILE
+
+
+        This jit option is used for internal purpose only.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_GLOBAL_SYMBOL_NAMES
+
+
+        Array of device symbol names that will be relocated to the corresponing host addresses stored in :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_ADDRESSES`.
+
+        Must contain :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_COUNT` entries.
+
+        When loding a device module, driver will relocate all encountered unresolved symbols to the host addresses.
+
+        It is only allowed to register symbols that correspond to unresolved global variables.
+
+        It is illegal to register the same device symbol at multiple addresses.
+
+        Option type: const char **
+
+        Applies to: dynamic linker only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_GLOBAL_SYMBOL_ADDRESSES
+
+
+        Array of host addresses that will be used to relocate corresponding device symbols stored in :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_NAMES`.
+
+        Must contain :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_COUNT` entries.
+
+        Option type: void **
+
+        Applies to: dynamic linker only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_GLOBAL_SYMBOL_COUNT
+
+
+        Number of entries in :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_NAMES` and :py:obj:`~.CU_JIT_GLOBAL_SYMBOL_ADDRESSES` arrays.
+
+        Option type: unsigned int
+
+        Applies to: dynamic linker only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_LTO
+
+
+        Enable link-time optimization (-dlto) for device code (Disabled by default).
+
+        This option is not supported on 32-bit platforms.
+
+        Option type: int
+
+        Applies to: compiler and linker
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_FTZ
+
+
+        Control single-precision denormals (-ftz) support (0: false, default). 1 : flushes denormal values to zero 0 : preserves denormal values Option type: int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_PREC_DIV
+
+
+        Control single-precision floating-point division and reciprocals (-prec-div) support (1: true, default). 1 : Enables the IEEE round-to-nearest mode 0 : Enables the fast approximation mode Option type: int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_PREC_SQRT
+
+
+        Control single-precision floating-point square root (-prec-sqrt) support (1: true, default). 1 : Enables the IEEE round-to-nearest mode 0 : Enables the fast approximation mode Option type: int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_FMA
+
+
+        Enable/Disable the contraction of floating-point multiplies and adds/subtracts into floating-point multiply-add (-fma) operations (1: Enable, default; 0: Disable). Option type: int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_REFERENCED_KERNEL_NAMES
+
+
+        Array of kernel names that should be preserved at link time while others can be removed.
+
+        Must contain :py:obj:`~.CU_JIT_REFERENCED_KERNEL_COUNT` entries.
+
+        Note that kernel names can be mangled by the compiler in which case the mangled name needs to be specified.
+
+        Wildcard "*" can be used to represent zero or more characters instead of specifying the full or mangled name.
+
+        It is important to note that the wildcard "*" is also added implicitly. For example, specifying "foo" will match "foobaz", "barfoo", "barfoobaz" and thus preserve all kernels with those names. This can be avoided by providing a more specific name like "barfoobaz".
+
+        Option type: const char **
+
+        Applies to: dynamic linker only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_REFERENCED_KERNEL_COUNT
+
+
+        Number of entries in :py:obj:`~.CU_JIT_REFERENCED_KERNEL_NAMES` array.
+
+        Option type: unsigned int
+
+        Applies to: dynamic linker only
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_REFERENCED_VARIABLE_NAMES
+
+
+        Array of variable names (device and/or constant) that should be preserved at link time while others can be removed.
+
+        Must contain :py:obj:`~.CU_JIT_REFERENCED_VARIABLE_COUNT` entries.
+
+        Note that variable names can be mangled by the compiler in which case the mangled name needs to be specified.
+
+        Wildcard "*" can be used to represent zero or more characters instead of specifying the full or mangled name.
+
+        It is important to note that the wildcard "*" is also added implicitly. For example, specifying "foo" will match "foobaz", "barfoo", "barfoobaz" and thus preserve all variables with those names. This can be avoided by providing a more specific name like "barfoobaz".
+
+        Option type: const char **
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_REFERENCED_VARIABLE_COUNT
+
+
+        Number of entries in :py:obj:`~.CU_JIT_REFERENCED_VARIABLE_NAMES` array.
+
+        Option type: unsigned int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_OPTIMIZE_UNUSED_DEVICE_VARIABLES
+
+
+        This option serves as a hint to enable the JIT compiler/linker to remove constant (constant) and device (device) variables unreferenced in device code (Disabled by default).
+
+        Note that host references to constant and device variables using APIs like :py:obj:`~.cuModuleGetGlobal()` with this option specified may result in undefined behavior unless the variables are explicitly specified using :py:obj:`~.CU_JIT_REFERENCED_VARIABLE_NAMES`.
+
+        Option type: int
+
+        Applies to: link-time optimization specified with CU_JIT_LTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_option.CU_JIT_NUM_OPTIONS
+
+.. autoclass:: cuda.bindings.driver.CUjit_target
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_20
+
+
+        Compute device class 2.0
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_21
+
+
+        Compute device class 2.1
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_30
+
+
+        Compute device class 3.0
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_32
+
+
+        Compute device class 3.2
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_35
+
+
+        Compute device class 3.5
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_37
+
+
+        Compute device class 3.7
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_50
+
+
+        Compute device class 5.0
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_52
+
+
+        Compute device class 5.2
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_53
+
+
+        Compute device class 5.3
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_60
+
+
+        Compute device class 6.0.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_61
+
+
+        Compute device class 6.1.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_62
+
+
+        Compute device class 6.2.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_70
+
+
+        Compute device class 7.0.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_72
+
+
+        Compute device class 7.2.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_75
+
+
+        Compute device class 7.5.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_80
+
+
+        Compute device class 8.0.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_86
+
+
+        Compute device class 8.6.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_87
+
+
+        Compute device class 8.7.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_89
+
+
+        Compute device class 8.9.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_target.CU_TARGET_COMPUTE_90
+
+
+        Compute device class 9.0.
+
+.. autoclass:: cuda.bindings.driver.CUjit_fallback
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_fallback.CU_PREFER_PTX
+
+
+        Prefer to compile ptx if exact binary match not found
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_fallback.CU_PREFER_BINARY
+
+
+        Prefer to fall back to compatible binary code if exact match not found
+
+.. autoclass:: cuda.bindings.driver.CUjit_cacheMode
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_cacheMode.CU_JIT_CACHE_OPTION_NONE
+
+
+        Compile with no -dlcm flag specified
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_cacheMode.CU_JIT_CACHE_OPTION_CG
+
+
+        Compile with L1 cache disabled
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjit_cacheMode.CU_JIT_CACHE_OPTION_CA
+
+
+        Compile with L1 cache enabled
+
+.. autoclass:: cuda.bindings.driver.CUjitInputType
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_CUBIN
+
+
+        Compiled device-class-specific device code
+
+        Applicable options: none
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_PTX
+
+
+        PTX source code
+
+        Applicable options: PTX compiler options
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_FATBINARY
+
+
+        Bundle of multiple cubins and/or PTX of some device code
+
+        Applicable options: PTX compiler options, :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_OBJECT
+
+
+        Host object with embedded device code
+
+        Applicable options: PTX compiler options, :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_LIBRARY
+
+
+        Archive of host objects with embedded device code
+
+        Applicable options: PTX compiler options, :py:obj:`~.CU_JIT_FALLBACK_STRATEGY`
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_INPUT_NVVM
+
+
+        High-level intermediate code for link-time optimization
+
+        Applicable options: NVVM compiler options, PTX compiler options
+
+
+    .. autoattribute:: cuda.bindings.driver.CUjitInputType.CU_JIT_NUM_INPUT_TYPES
+
+.. autoclass:: cuda.bindings.driver.CUgraphicsRegisterFlags
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsRegisterFlags.CU_GRAPHICS_REGISTER_FLAGS_NONE
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsRegisterFlags.CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsRegisterFlags.CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsRegisterFlags.CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsRegisterFlags.CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER
+
+.. autoclass:: cuda.bindings.driver.CUgraphicsMapResourceFlags
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsMapResourceFlags.CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsMapResourceFlags.CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphicsMapResourceFlags.CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD
+
+.. autoclass:: cuda.bindings.driver.CUarray_cubemap_face
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_POSITIVE_X
+
+
+        Positive X face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_NEGATIVE_X
+
+
+        Negative X face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_POSITIVE_Y
+
+
+        Positive Y face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_NEGATIVE_Y
+
+
+        Negative Y face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_POSITIVE_Z
+
+
+        Positive Z face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarray_cubemap_face.CU_CUBEMAP_FACE_NEGATIVE_Z
+
+
+        Negative Z face of cubemap
+
+.. autoclass:: cuda.bindings.driver.CUlimit
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_STACK_SIZE
+
+
+        GPU thread stack size
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_PRINTF_FIFO_SIZE
+
+
+        GPU printf FIFO size
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_MALLOC_HEAP_SIZE
+
+
+        GPU malloc heap size
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH
+
+
+        GPU device runtime launch synchronize depth
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT
+
+
+        GPU device runtime pending launch count
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_MAX_L2_FETCH_GRANULARITY
+
+
+        A value between 0 and 128 that indicates the maximum fetch granularity of L2 (in Bytes). This is a hint
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_PERSISTING_L2_CACHE_SIZE
+
+
+        A size in bytes for L2 persisting lines cache size
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlimit.CU_LIMIT_MAX
+
+.. autoclass:: cuda.bindings.driver.CUresourcetype
+
+    .. autoattribute:: cuda.bindings.driver.CUresourcetype.CU_RESOURCE_TYPE_ARRAY
+
+
+        Array resoure
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourcetype.CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
+
+
+        Mipmapped array resource
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourcetype.CU_RESOURCE_TYPE_LINEAR
+
+
+        Linear resource
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourcetype.CU_RESOURCE_TYPE_PITCH2D
+
+
+        Pitch 2D resource
+
+.. autoclass:: cuda.bindings.driver.CUaccessProperty
+
+    .. autoattribute:: cuda.bindings.driver.CUaccessProperty.CU_ACCESS_PROPERTY_NORMAL
+
+
+        Normal cache persistence.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUaccessProperty.CU_ACCESS_PROPERTY_STREAMING
+
+
+        Streaming access is less likely to persit from cache.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUaccessProperty.CU_ACCESS_PROPERTY_PERSISTING
+
+
+        Persisting access is more likely to persist in cache.
+
+.. autoclass:: cuda.bindings.driver.CUgraphNodeType
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_KERNEL
+
+
+        GPU kernel node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_MEMCPY
+
+
+        Memcpy node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_MEMSET
+
+
+        Memset node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_HOST
+
+
+        Host (executable) node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_GRAPH
+
+
+        Node which executes an embedded graph
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_EMPTY
+
+
+        Empty (no-op) node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_WAIT_EVENT
+
+
+        External event wait node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_EVENT_RECORD
+
+
+        External event record node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_EXT_SEMAS_SIGNAL
+
+
+        External semaphore signal node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_EXT_SEMAS_WAIT
+
+
+        External semaphore wait node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_MEM_ALLOC
+
+
+        Memory Allocation Node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_MEM_FREE
+
+
+        Memory Free Node
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphNodeType.CU_GRAPH_NODE_TYPE_BATCH_MEM_OP
+
+
+        Batch MemOp Node
+
+.. autoclass:: cuda.bindings.driver.CUsynchronizationPolicy
+
+    .. autoattribute:: cuda.bindings.driver.CUsynchronizationPolicy.CU_SYNC_POLICY_AUTO
+
+
+    .. autoattribute:: cuda.bindings.driver.CUsynchronizationPolicy.CU_SYNC_POLICY_SPIN
+
+
+    .. autoattribute:: cuda.bindings.driver.CUsynchronizationPolicy.CU_SYNC_POLICY_YIELD
+
+
+    .. autoattribute:: cuda.bindings.driver.CUsynchronizationPolicy.CU_SYNC_POLICY_BLOCKING_SYNC
+
+.. autoclass:: cuda.bindings.driver.CUclusterSchedulingPolicy
+
+    .. autoattribute:: cuda.bindings.driver.CUclusterSchedulingPolicy.CU_CLUSTER_SCHEDULING_POLICY_DEFAULT
+
+
+        the default policy
+
+
+    .. autoattribute:: cuda.bindings.driver.CUclusterSchedulingPolicy.CU_CLUSTER_SCHEDULING_POLICY_SPREAD
+
+
+        spread the blocks within a cluster to the SMs
+
+
+    .. autoattribute:: cuda.bindings.driver.CUclusterSchedulingPolicy.CU_CLUSTER_SCHEDULING_POLICY_LOAD_BALANCING
+
+
+        allow the hardware to load-balance the blocks in a cluster to the SMs
+
+.. autoclass:: cuda.bindings.driver.CUlaunchAttributeID
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_IGNORE
+
+
+        Ignored entry, for convenient composition
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_ACCESS_POLICY_WINDOW
+
+
+        Valid for streams, graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_COOPERATIVE
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_SYNCHRONIZATION_POLICY
+
+
+        Valid for streams.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_CLUSTER_DIMENSION
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_STREAM_SERIALIZATION
+
+
+        Valid for launches. Setting programmaticStreamSerializationAllowed to non-0 signals that the kernel will use programmatic means to resolve its stream dependency, so that the CUDA runtime should opportunistically allow the grid's execution to overlap with the previous kernel in the stream, if that kernel requests the overlap.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PROGRAMMATIC_EVENT
+
+
+        Valid for launches. Event recorded through this launch attribute is guaranteed to only trigger after all block in the associated kernel trigger the event. A block can trigger the event through PTX griddepcontrol.launch_dependents. A trigger can also be inserted at the beginning of each block's execution if triggerAtBlockStart is set to non-0. Note that dependents (including the CPU thread calling :py:obj:`~.cuEventSynchronize()`) are not guaranteed to observe the release precisely when it is released. For example, :py:obj:`~.cuEventSynchronize()` may only observe the event trigger long after the associated kernel has completed. This recording type is primarily meant for establishing programmatic dependency between device tasks. The event supplied must not be an interprocess or interop event. The event must disable timing (i.e. created with :py:obj:`~.CU_EVENT_DISABLE_TIMING` flag set).
+
+
+    .. autoattribute:: cuda.bindings.driver.CUlaunchAttributeID.CU_LAUNCH_ATTRIBUTE_PRIORITY
+
+
+        Valid for graph nodes.
+
+.. autoclass:: cuda.bindings.driver.CUstreamCaptureStatus
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureStatus.CU_STREAM_CAPTURE_STATUS_NONE
+
+
+        Stream is not capturing
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureStatus.CU_STREAM_CAPTURE_STATUS_ACTIVE
+
+
+        Stream is actively capturing
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureStatus.CU_STREAM_CAPTURE_STATUS_INVALIDATED
+
+
+        Stream is part of a capture sequence that has been invalidated, but not terminated
+
+.. autoclass:: cuda.bindings.driver.CUstreamCaptureMode
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureMode.CU_STREAM_CAPTURE_MODE_GLOBAL
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureMode.CU_STREAM_CAPTURE_MODE_THREAD_LOCAL
+
+
+    .. autoattribute:: cuda.bindings.driver.CUstreamCaptureMode.CU_STREAM_CAPTURE_MODE_RELAXED
+
+.. autoclass:: cuda.bindings.driver.CUdriverProcAddress_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUdriverProcAddress_flags.CU_GET_PROC_ADDRESS_DEFAULT
+
+
+        Default search mode for driver symbols.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdriverProcAddress_flags.CU_GET_PROC_ADDRESS_LEGACY_STREAM
+
+
+        Search for legacy versions of driver symbols.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdriverProcAddress_flags.CU_GET_PROC_ADDRESS_PER_THREAD_DEFAULT_STREAM
+
+
+        Search for per-thread versions of driver symbols.
+
+.. autoclass:: cuda.bindings.driver.CUexecAffinityType
+
+    .. autoattribute:: cuda.bindings.driver.CUexecAffinityType.CU_EXEC_AFFINITY_TYPE_SM_COUNT
+
+
+        Create a context with limited SMs.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexecAffinityType.CU_EXEC_AFFINITY_TYPE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUresult
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_SUCCESS
+
+
+        The API call returned with no errors. In the case of query calls, this also means that the operation being queried is complete (see :py:obj:`~.cuEventQuery()` and :py:obj:`~.cuStreamQuery()`).
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_VALUE
+
+
+        This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_OUT_OF_MEMORY
+
+
+        The API call failed because it was unable to allocate enough memory to perform the requested operation.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_INITIALIZED
+
+
+        This indicates that the CUDA driver has not been initialized with :py:obj:`~.cuInit()` or that initialization has failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_DEINITIALIZED
+
+
+        This indicates that the CUDA driver is in the process of shutting down.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PROFILER_DISABLED
+
+
+        This indicates profiler is not initialized for this run. This can happen when the application is running with external profiling tools like visual profiler.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PROFILER_NOT_INITIALIZED
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PROFILER_ALREADY_STARTED
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PROFILER_ALREADY_STOPPED
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STUB_LIBRARY
+
+
+        This indicates that the CUDA driver that the application has loaded is a stub library. Applications that run with the stub rather than a real driver loaded will result in CUDA API returning this error.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_DEVICE_UNAVAILABLE
+
+
+        This indicates that requested CUDA device is unavailable at the current time. Devices are often unavailable due to use of :py:obj:`~.CU_COMPUTEMODE_EXCLUSIVE_PROCESS` or :py:obj:`~.CU_COMPUTEMODE_PROHIBITED`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NO_DEVICE
+
+
+        This indicates that no CUDA-capable devices were detected by the installed CUDA driver.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_DEVICE
+
+
+        This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device or that the action requested is invalid for the specified device.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_DEVICE_NOT_LICENSED
+
+
+        This error indicates that the Grid license is not applied.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_IMAGE
+
+
+        This indicates that the device kernel image is invalid. This can also indicate an invalid CUDA module.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_CONTEXT
+
+
+        This most frequently indicates that there is no context bound to the current thread. This can also be returned if the context passed to an API call is not a valid handle (such as a context that has had :py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned if a user mixes different API versions (i.e. 3010 context with 3020 API calls). See :py:obj:`~.cuCtxGetApiVersion()` for more details.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_CONTEXT_ALREADY_CURRENT
+
+
+        This indicated that the context being supplied as a parameter to the API call was already the active context. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MAP_FAILED
+
+
+        This indicates that a map or register operation has failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_UNMAP_FAILED
+
+
+        This indicates that an unmap or unregister operation has failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ARRAY_IS_MAPPED
+
+
+        This indicates that the specified array is currently mapped and thus cannot be destroyed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ALREADY_MAPPED
+
+
+        This indicates that the resource is already mapped.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NO_BINARY_FOR_GPU
+
+
+        This indicates that there is no kernel image available that is suitable for the device. This can occur when a user specifies code generation options for a particular CUDA source file that do not include the corresponding device configuration.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ALREADY_ACQUIRED
+
+
+        This indicates that a resource has already been acquired.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_MAPPED
+
+
+        This indicates that a resource is not mapped.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_MAPPED_AS_ARRAY
+
+
+        This indicates that a mapped resource is not available for access as an array.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_MAPPED_AS_POINTER
+
+
+        This indicates that a mapped resource is not available for access as a pointer.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ECC_UNCORRECTABLE
+
+
+        This indicates that an uncorrectable ECC error was detected during execution.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_UNSUPPORTED_LIMIT
+
+
+        This indicates that the :py:obj:`~.CUlimit` passed to the API call is not supported by the active device.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_CONTEXT_ALREADY_IN_USE
+
+
+        This indicates that the :py:obj:`~.CUcontext` passed to the API call can only be bound to a single CPU thread at a time but is already bound to a CPU thread.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PEER_ACCESS_UNSUPPORTED
+
+
+        This indicates that peer access is not supported across the given devices.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_PTX
+
+
+        This indicates that a PTX JIT compilation failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_GRAPHICS_CONTEXT
+
+
+        This indicates an error with OpenGL or DirectX context.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NVLINK_UNCORRECTABLE
+
+
+        This indicates that an uncorrectable NVLink error was detected during the execution.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_JIT_COMPILER_NOT_FOUND
+
+
+        This indicates that the PTX JIT compiler library was not found.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_UNSUPPORTED_PTX_VERSION
+
+
+        This indicates that the provided PTX was compiled with an unsupported toolchain.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_JIT_COMPILATION_DISABLED
+
+
+        This indicates that the PTX JIT compilation was disabled.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_UNSUPPORTED_EXEC_AFFINITY
+
+
+        This indicates that the :py:obj:`~.CUexecAffinityType` passed to the API call is not supported by the active device.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_SOURCE
+
+
+        This indicates that the device kernel source is invalid. This includes compilation/linker errors encountered in device code or user error.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_FILE_NOT_FOUND
+
+
+        This indicates that the file specified was not found.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND
+
+
+        This indicates that a link to a shared object failed to resolve.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_SHARED_OBJECT_INIT_FAILED
+
+
+        This indicates that initialization of a shared object failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_OPERATING_SYSTEM
+
+
+        This indicates that an OS call failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_HANDLE
+
+
+        This indicates that a resource handle passed to the API call was not valid. Resource handles are opaque types like :py:obj:`~.CUstream` and :py:obj:`~.CUevent`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ILLEGAL_STATE
+
+
+        This indicates that a resource required by the API call is not in a valid state to perform the requested operation.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_FOUND
+
+
+        This indicates that a named symbol was not found. Examples of symbols are global/constant variable names, driver function names, texture names, and surface names.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_READY
+
+
+        This indicates that asynchronous operations issued previously have not completed yet. This result is not actually an error, but must be indicated differently than :py:obj:`~.CUDA_SUCCESS` (which indicates completion). Calls that may return this value include :py:obj:`~.cuEventQuery()` and :py:obj:`~.cuStreamQuery()`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ILLEGAL_ADDRESS
+
+
+        While executing a kernel, the device encountered a load or store instruction on an invalid memory address. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES
+
+
+        This indicates that a launch did not occur because it did not have appropriate resources. This error usually indicates that the user has attempted to pass too many arguments to the device kernel, or the kernel launch specifies too many threads for the kernel's register count. Passing arguments of the wrong size (i.e. a 64-bit pointer when a 32-bit int is expected) is equivalent to passing too many arguments and can also result in this error.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_LAUNCH_TIMEOUT
+
+
+        This indicates that the device kernel took too long to execute. This can only occur if timeouts are enabled - see the device attribute :py:obj:`~.CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT` for more information. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING
+
+
+        This error indicates a kernel launch that uses an incompatible texturing mode.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED
+
+
+        This error indicates that a call to :py:obj:`~.cuCtxEnablePeerAccess()` is trying to re-enable peer access to a context which has already had peer access to it enabled.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PEER_ACCESS_NOT_ENABLED
+
+
+        This error indicates that :py:obj:`~.cuCtxDisablePeerAccess()` is trying to disable peer access which has not been enabled yet via :py:obj:`~.cuCtxEnablePeerAccess()`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE
+
+
+        This error indicates that the primary context for the specified device has already been initialized.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_CONTEXT_IS_DESTROYED
+
+
+        This error indicates that the context current to the calling thread has been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary context which has not yet been initialized.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ASSERT
+
+
+        A device-side assert triggered during kernel execution. The context cannot be used anymore, and must be destroyed. All existing device memory allocations from this context are invalid and must be reconstructed if the program is to continue using CUDA.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_TOO_MANY_PEERS
+
+
+        This error indicates that the hardware resources required to enable peer access have been exhausted for one or more of the devices passed to :py:obj:`~.cuCtxEnablePeerAccess()`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED
+
+
+        This error indicates that the memory range passed to :py:obj:`~.cuMemHostRegister()` has already been registered.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED
+
+
+        This error indicates that the pointer passed to :py:obj:`~.cuMemHostUnregister()` does not correspond to any currently registered memory region.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_HARDWARE_STACK_ERROR
+
+
+        While executing a kernel, the device encountered a stack error. This can be due to stack corruption or exceeding the stack size limit. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_ILLEGAL_INSTRUCTION
+
+
+        While executing a kernel, the device encountered an illegal instruction. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MISALIGNED_ADDRESS
+
+
+        While executing a kernel, the device encountered a load or store instruction on a memory address which is not aligned. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_ADDRESS_SPACE
+
+
+        While executing a kernel, the device encountered an instruction which can only operate on memory locations in certain address spaces (global, shared, or local), but was supplied a memory address not belonging to an allowed address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_PC
+
+
+        While executing a kernel, the device program counter wrapped its address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_LAUNCH_FAILED
+
+
+        An exception occurred on the device while executing a kernel. Common causes include dereferencing an invalid device pointer and accessing out of bounds shared memory. Less common cases can be system specific - more information about these cases can be found in the system specific user guide. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE
+
+
+        This error indicates that the number of blocks launched per grid for a kernel that was launched via either :py:obj:`~.cuLaunchCooperativeKernel` or :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` exceeds the maximum number of blocks as allowed by :py:obj:`~.cuOccupancyMaxActiveBlocksPerMultiprocessor` or :py:obj:`~.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` times the number of multiprocessors as specified by the device attribute :py:obj:`~.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT`.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_PERMITTED
+
+
+        This error indicates that the attempted operation is not permitted.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_NOT_SUPPORTED
+
+
+        This error indicates that the attempted operation is not supported on the current system or device.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_SYSTEM_NOT_READY
+
+
+        This error indicates that the system is not yet ready to start any CUDA work. To continue using CUDA, verify the system configuration is in a valid state and all required driver daemons are actively running. More information about this error can be found in the system specific user guide.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_SYSTEM_DRIVER_MISMATCH
+
+
+        This error indicates that there is a mismatch between the versions of the display driver and the CUDA driver. Refer to the compatibility documentation for supported versions.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE
+
+
+        This error indicates that the system was upgraded to run with forward compatibility but the visible hardware detected by CUDA does not support this configuration. Refer to the compatibility documentation for the supported hardware matrix or ensure that only supported hardware is visible during initialization via the CUDA_VISIBLE_DEVICES environment variable.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_CONNECTION_FAILED
+
+
+        This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_RPC_FAILURE
+
+
+        This error indicates that the remote procedural call between the MPS server and the MPS client failed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_SERVER_NOT_READY
+
+
+        This error indicates that the MPS server is not ready to accept new MPS client requests. This error can be returned when the MPS server is in the process of recovering from a fatal failure.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_MAX_CLIENTS_REACHED
+
+
+        This error indicates that the hardware resources required to create MPS client have been exhausted.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_MAX_CONNECTIONS_REACHED
+
+
+        This error indicates the the hardware resources required to support device connections have been exhausted.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_MPS_CLIENT_TERMINATED
+
+
+        This error indicates that the MPS client has been terminated by the server. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED
+
+
+        This error indicates that the operation is not permitted when the stream is capturing.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_INVALIDATED
+
+
+        This error indicates that the current capture sequence on the stream has been invalidated due to a previous error.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_MERGE
+
+
+        This error indicates that the operation would have resulted in a merge of two independent capture sequences.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_UNMATCHED
+
+
+        This error indicates that the capture was not initiated in this stream.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_UNJOINED
+
+
+        This error indicates that the capture sequence contains a fork that was not joined to the primary stream.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_ISOLATION
+
+
+        This error indicates that a dependency would have been created which crosses the capture sequence boundary. Only implicit in-stream ordering dependencies are allowed to cross the boundary.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_IMPLICIT
+
+
+        This error indicates a disallowed implicit dependency on a current capture sequence from cudaStreamLegacy.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_CAPTURED_EVENT
+
+
+        This error indicates that the operation is not permitted on an event which was last recorded in a capturing stream.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD
+
+
+        A stream capture sequence not initiated with the :py:obj:`~.CU_STREAM_CAPTURE_MODE_RELAXED` argument to :py:obj:`~.cuStreamBeginCapture` was passed to :py:obj:`~.cuStreamEndCapture` in a different thread.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_TIMEOUT
+
+
+        This error indicates that the timeout specified for the wait operation has lapsed.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE
+
+
+        This error indicates that the graph update was not performed because it included changes which violated constraints specific to instantiated graph update.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_EXTERNAL_DEVICE
+
+
+        This indicates that an async error has occurred in a device outside of CUDA. If CUDA was waiting for an external device's signal before consuming shared data, the external device signaled an error indicating that the data is not valid for consumption. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_INVALID_CLUSTER_SIZE
+
+
+        Indicates a kernel launch error due to cluster misconfiguration.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresult.CUDA_ERROR_UNKNOWN
+
+
+        This indicates that an unknown internal error has occurred.
+
+.. autoclass:: cuda.bindings.driver.CUdevice_P2PAttribute
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_P2PAttribute.CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK
+
+
+        A relative value indicating the performance of the link between two devices
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_P2PAttribute.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED
+
+
+        P2P Access is enable
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_P2PAttribute.CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED
+
+
+        Atomic operation over the link supported
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_P2PAttribute.CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.driver.CUdevice_P2PAttribute.CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED
+
+
+        Accessing CUDA arrays over the link supported
+
+.. autoclass:: cuda.bindings.driver.CUresourceViewFormat
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_NONE
+
+
+        No resource view format (use underlying resource format)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_1X8
+
+
+        1 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_2X8
+
+
+        2 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_4X8
+
+
+        4 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_1X8
+
+
+        1 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_2X8
+
+
+        2 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_4X8
+
+
+        4 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_1X16
+
+
+        1 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_2X16
+
+
+        2 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_4X16
+
+
+        4 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_1X16
+
+
+        1 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_2X16
+
+
+        2 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_4X16
+
+
+        4 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_1X32
+
+
+        1 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_2X32
+
+
+        2 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UINT_4X32
+
+
+        4 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_1X32
+
+
+        1 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_2X32
+
+
+        2 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SINT_4X32
+
+
+        4 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_1X16
+
+
+        1 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_2X16
+
+
+        2 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_4X16
+
+
+        4 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_1X32
+
+
+        1 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_2X32
+
+
+        2 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_FLOAT_4X32
+
+
+        4 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC1
+
+
+        Block compressed 1
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC2
+
+
+        Block compressed 2
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC3
+
+
+        Block compressed 3
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC4
+
+
+        Block compressed 4 unsigned
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SIGNED_BC4
+
+
+        Block compressed 4 signed
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC5
+
+
+        Block compressed 5 unsigned
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SIGNED_BC5
+
+
+        Block compressed 5 signed
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC6H
+
+
+        Block compressed 6 unsigned half-float
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_SIGNED_BC6H
+
+
+        Block compressed 6 signed half-float
+
+
+    .. autoattribute:: cuda.bindings.driver.CUresourceViewFormat.CU_RES_VIEW_FORMAT_UNSIGNED_BC7
+
+
+        Block compressed 7
+
+.. autoclass:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS
+
+    .. autoattribute:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_NONE
+
+
+        No access, meaning the device cannot access this memory at all, thus must be staged through accessible memory in order to complete certain operations
+
+
+    .. autoattribute:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READ
+
+
+        Read-only access, meaning writes to this memory are considered invalid accesses and thus return error in that case.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_ACCESS_FLAGS.CU_POINTER_ATTRIBUTE_ACCESS_FLAG_READWRITE
+
+
+        Read-write access, the device has full read-write access to the memory
+
+.. autoclass:: cuda.bindings.driver.CUexternalMemoryHandleType
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD
+
+
+        Handle is an opaque file descriptor
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
+
+
+        Handle is an opaque shared NT handle
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
+
+
+        Handle is an opaque, globally shared handle
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
+
+
+        Handle is a D3D12 heap object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
+
+
+        Handle is a D3D12 committed resource
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE
+
+
+        Handle is a shared NT handle to a D3D11 resource
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
+
+
+        Handle is a globally shared handle to a D3D11 resource
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalMemoryHandleType.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF
+
+
+        Handle is an NvSciBuf object
+
+.. autoclass:: cuda.bindings.driver.CUexternalSemaphoreHandleType
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD
+
+
+        Handle is an opaque file descriptor
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
+
+
+        Handle is an opaque shared NT handle
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT
+
+
+        Handle is an opaque, globally shared handle
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
+
+
+        Handle is a shared NT handle referencing a D3D12 fence object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
+
+
+        Handle is a shared NT handle referencing a D3D11 fence object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC
+
+
+        Opaque handle to NvSciSync Object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
+
+
+        Handle is a shared NT handle referencing a D3D11 keyed mutex object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT
+
+
+        Handle is a globally shared handle referencing a D3D11 keyed mutex object
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_FD
+
+
+        Handle is an opaque file descriptor referencing a timeline semaphore
+
+
+    .. autoattribute:: cuda.bindings.driver.CUexternalSemaphoreHandleType.CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TIMELINE_SEMAPHORE_WIN32
+
+
+        Handle is an opaque shared NT handle referencing a timeline semaphore
+
+.. autoclass:: cuda.bindings.driver.CUmemAllocationHandleType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_NONE
+
+
+        Does not allow any export mechanism. >
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
+
+
+        Allows a file descriptor to be used for exporting. Permitted only on POSIX systems. (int)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_WIN32
+
+
+        Allows a Win32 NT handle to be used for exporting. (HANDLE)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_WIN32_KMT
+
+
+        Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationHandleType.CU_MEM_HANDLE_TYPE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUmemAccess_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_NONE
+
+
+        Default, make the address range not accessible
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READ
+
+
+        Make the address range read accessible
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_READWRITE
+
+
+        Make the address range read-write accessible
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAccess_flags.CU_MEM_ACCESS_FLAGS_PROT_MAX
+
+.. autoclass:: cuda.bindings.driver.CUmemLocationType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemLocationType.CU_MEM_LOCATION_TYPE_INVALID
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemLocationType.CU_MEM_LOCATION_TYPE_DEVICE
+
+
+        Location is a device location, thus id is a device ordinal
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemLocationType.CU_MEM_LOCATION_TYPE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUmemAllocationType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_INVALID
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_PINNED
+
+
+        This allocation type is 'pinned', i.e. cannot migrate from its current location while the application is actively using it
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationType.CU_MEM_ALLOCATION_TYPE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUmemAllocationGranularity_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationGranularity_flags.CU_MEM_ALLOC_GRANULARITY_MINIMUM
+
+
+        Minimum required granularity for allocation
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationGranularity_flags.CU_MEM_ALLOC_GRANULARITY_RECOMMENDED
+
+
+        Recommended granularity for allocation for best performance
+
+.. autoclass:: cuda.bindings.driver.CUmemRangeHandleType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemRangeHandleType.CU_MEM_RANGE_HANDLE_TYPE_DMA_BUF_FD
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemRangeHandleType.CU_MEM_RANGE_HANDLE_TYPE_MAX
+
+.. autoclass:: cuda.bindings.driver.CUarraySparseSubresourceType
+
+    .. autoattribute:: cuda.bindings.driver.CUarraySparseSubresourceType.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_SPARSE_LEVEL
+
+
+    .. autoattribute:: cuda.bindings.driver.CUarraySparseSubresourceType.CU_ARRAY_SPARSE_SUBRESOURCE_TYPE_MIPTAIL
+
+.. autoclass:: cuda.bindings.driver.CUmemOperationType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemOperationType.CU_MEM_OPERATION_TYPE_MAP
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemOperationType.CU_MEM_OPERATION_TYPE_UNMAP
+
+.. autoclass:: cuda.bindings.driver.CUmemHandleType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemHandleType.CU_MEM_HANDLE_TYPE_GENERIC
+
+.. autoclass:: cuda.bindings.driver.CUmemAllocationCompType
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationCompType.CU_MEM_ALLOCATION_COMP_NONE
+
+
+        Allocating non-compressible memory
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemAllocationCompType.CU_MEM_ALLOCATION_COMP_GENERIC
+
+
+        Allocating compressible memory
+
+.. autoclass:: cuda.bindings.driver.CUgraphExecUpdateResult
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_SUCCESS
+
+
+        The update succeeded
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR
+
+
+        The update failed for an unexpected reason which is described in the return value of the function
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED
+
+
+        The update failed because the topology changed
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED
+
+
+        The update failed because a node type changed
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED
+
+
+        The update failed because the function of a kernel node changed (CUDA driver < 11.2)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED
+
+
+        The update failed because the parameters changed in a way that is not supported
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED
+
+
+        The update failed because something about the node is not supported
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_UNSUPPORTED_FUNCTION_CHANGE
+
+
+        The update failed because the function of a kernel node changed in an unsupported way
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphExecUpdateResult.CU_GRAPH_EXEC_UPDATE_ERROR_ATTRIBUTES_CHANGED
+
+
+        The update failed because the node attributes changed in a way that is not supported
+
+.. autoclass:: cuda.bindings.driver.CUmemPool_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_REUSE_FOLLOW_EVENT_DEPENDENCIES
+
+
+        (value type = int) Allow cuMemAllocAsync to use memory asynchronously freed in another streams as long as a stream ordering dependency of the allocating stream on the free action exists. Cuda events and null stream interactions can create the required stream ordered dependencies. (default enabled)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_REUSE_ALLOW_OPPORTUNISTIC
+
+
+        (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_REUSE_ALLOW_INTERNAL_DEPENDENCIES
+
+
+        (value type = int) Allow cuMemAllocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by cuFreeAsync (default enabled).
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_RELEASE_THRESHOLD
+
+
+        (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_RESERVED_MEM_CURRENT
+
+
+        (value type = cuuint64_t) Amount of backing memory currently allocated for the mempool.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_RESERVED_MEM_HIGH
+
+
+        (value type = cuuint64_t) High watermark of backing memory allocated for the mempool since the last time it was reset. High watermark can only be reset to zero.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_USED_MEM_CURRENT
+
+
+        (value type = cuuint64_t) Amount of memory from the pool that is currently in use by the application.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmemPool_attribute.CU_MEMPOOL_ATTR_USED_MEM_HIGH
+
+
+        (value type = cuuint64_t) High watermark of the amount of memory from the pool that was in use by the application since the last time it was reset. High watermark can only be reset to zero.
+
+.. autoclass:: cuda.bindings.driver.CUgraphMem_attribute
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphMem_attribute.CU_GRAPH_MEM_ATTR_USED_MEM_CURRENT
+
+
+        (value type = cuuint64_t) Amount of memory, in bytes, currently associated with graphs
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphMem_attribute.CU_GRAPH_MEM_ATTR_USED_MEM_HIGH
+
+
+        (value type = cuuint64_t) High watermark of memory, in bytes, associated with graphs since the last time it was reset. High watermark can only be reset to zero.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphMem_attribute.CU_GRAPH_MEM_ATTR_RESERVED_MEM_CURRENT
+
+
+        (value type = cuuint64_t) Amount of memory, in bytes, currently allocated for use by the CUDA graphs asynchronous allocator.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphMem_attribute.CU_GRAPH_MEM_ATTR_RESERVED_MEM_HIGH
+
+
+        (value type = cuuint64_t) High watermark of memory, in bytes, currently allocated for use by the CUDA graphs asynchronous allocator.
+
+.. autoclass:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesOptions
+
+    .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesOptions.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_HOST
+
+
+        :py:obj:`~.cuFlushGPUDirectRDMAWrites()` and its CUDA Runtime API counterpart are supported on the device.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesOptions.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_OPTION_MEMOPS
+
+
+        The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported on the device.
+
+.. autoclass:: cuda.bindings.driver.CUGPUDirectRDMAWritesOrdering
+
+    .. autoattribute:: cuda.bindings.driver.CUGPUDirectRDMAWritesOrdering.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_NONE
+
+
+        The device does not natively support ordering of remote writes. :py:obj:`~.cuFlushGPUDirectRDMAWrites()` can be leveraged if supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUGPUDirectRDMAWritesOrdering.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_OWNER
+
+
+        Natively, the device can consistently consume remote writes, although other CUDA devices may not.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUGPUDirectRDMAWritesOrdering.CU_GPU_DIRECT_RDMA_WRITES_ORDERING_ALL_DEVICES
+
+
+        Any CUDA device in the system can consistently consume remote writes to this device.
+
+.. autoclass:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesScope
+
+    .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesScope.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_OWNER
+
+
+        Blocks until remote writes are visible to the CUDA device context owning the data.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesScope.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TO_ALL_DEVICES
+
+
+        Blocks until remote writes are visible to all CUDA device contexts.
+
+.. autoclass:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesTarget
+
+    .. autoattribute:: cuda.bindings.driver.CUflushGPUDirectRDMAWritesTarget.CU_FLUSH_GPU_DIRECT_RDMA_WRITES_TARGET_CURRENT_CTX
+
+
+        Sets the target for :py:obj:`~.cuFlushGPUDirectRDMAWrites()` to the currently active CUDA device context.
+
+.. autoclass:: cuda.bindings.driver.CUgraphDebugDot_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_VERBOSE
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_RUNTIME_TYPES
+
+
+        Output all debug data as if every debug flag is enabled
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_PARAMS
+
+
+        Use CUDA Runtime structures for output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_MEMCPY_NODE_PARAMS
+
+
+        Adds CUDA_KERNEL_NODE_PARAMS values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_MEMSET_NODE_PARAMS
+
+
+        Adds CUDA_MEMCPY3D values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_HOST_NODE_PARAMS
+
+
+        Adds CUDA_MEMSET_NODE_PARAMS values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_EVENT_NODE_PARAMS
+
+
+        Adds CUDA_HOST_NODE_PARAMS values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_SIGNAL_NODE_PARAMS
+
+
+        Adds CUevent handle from record and wait nodes to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_EXT_SEMAS_WAIT_NODE_PARAMS
+
+
+        Adds CUDA_EXT_SEM_SIGNAL_NODE_PARAMS values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_KERNEL_NODE_ATTRIBUTES
+
+
+        Adds CUDA_EXT_SEM_WAIT_NODE_PARAMS values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_HANDLES
+
+
+        Adds CUkernelNodeAttrValue values to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_ALLOC_NODE_PARAMS
+
+
+        Adds node handles and every kernel function handle to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_MEM_FREE_NODE_PARAMS
+
+
+        Adds memory alloc node parameters to output
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphDebugDot_flags.CU_GRAPH_DEBUG_DOT_FLAGS_BATCH_MEM_OP_NODE_PARAMS
+
+.. autoclass:: cuda.bindings.driver.CUuserObject_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUuserObject_flags.CU_USER_OBJECT_NO_DESTRUCTOR_SYNC
+
+
+        Indicates the destructor execution is not synchronized by any CUDA handle.
+
+.. autoclass:: cuda.bindings.driver.CUuserObjectRetain_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUuserObjectRetain_flags.CU_GRAPH_USER_OBJECT_MOVE
+
+
+        Transfer references from the caller rather than creating new references.
+
+.. autoclass:: cuda.bindings.driver.CUgraphInstantiate_flags
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_AUTO_FREE_ON_LAUNCH
+
+
+        Automatically free memory allocated in a graph before relaunching.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUgraphInstantiate_flags.CUDA_GRAPH_INSTANTIATE_FLAG_USE_NODE_PRIORITY
+
+
+        Run the graph using the per-node priority attributes rather than the priority of the stream it is launched into.
+
+.. autoclass:: cuda.bindings.driver.CUeglFrameType
+
+    .. autoattribute:: cuda.bindings.driver.CUeglFrameType.CU_EGL_FRAME_TYPE_ARRAY
+
+
+        Frame type CUDA array
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglFrameType.CU_EGL_FRAME_TYPE_PITCH
+
+
+        Frame type pointer
+
+.. autoclass:: cuda.bindings.driver.CUeglResourceLocationFlags
+
+    .. autoattribute:: cuda.bindings.driver.CUeglResourceLocationFlags.CU_EGL_RESOURCE_LOCATION_SYSMEM
+
+
+        Resource location sysmem
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglResourceLocationFlags.CU_EGL_RESOURCE_LOCATION_VIDMEM
+
+
+        Resource location vidmem
+
+.. autoclass:: cuda.bindings.driver.CUeglColorFormat
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_PLANAR
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR
+
+
+        Y, UV in two surfaces (UV as one surface) with VU byte ordering, width, height ratio same as YUV420Planar.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV422_PLANAR
+
+
+        Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR
+
+
+        Y, UV in two surfaces with VU byte ordering, width, height ratio same as YUV422Planar.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_RGB
+
+
+        R/G/B three channels in one surface with BGR byte ordering. Only pitch linear format supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BGR
+
+
+        R/G/B three channels in one surface with RGB byte ordering. Only pitch linear format supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_ARGB
+
+
+        R/G/B/A four channels in one surface with BGRA byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_RGBA
+
+
+        R/G/B/A four channels in one surface with ABGR byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_L
+
+
+        single luminance channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_R
+
+
+        single color channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV444_PLANAR
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR
+
+
+        Y, UV in two surfaces (UV as one surface) with VU byte ordering, width, height ratio same as YUV444Planar.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUYV_422
+
+
+        Y, U, V in one surface, interleaved as UYVY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_UYVY_422
+
+
+        Y, U, V in one surface, interleaved as YUYV in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_ABGR
+
+
+        R/G/B/A four channels in one surface with RGBA byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BGRA
+
+
+        R/G/B/A four channels in one surface with ARGB byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_A
+
+
+        Alpha color format - one channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_RG
+
+
+        R/G color format - two channels in one surface with GR byte ordering
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_AYUV
+
+
+        Y, U, V, A four channels in one surface, interleaved as VUYA.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR
+
+
+        Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR
+
+
+        Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_VYUY_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as YVYU in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_UYVY_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as YUYV in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUYV_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as UYVY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVYU_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as VYUY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV_ER
+
+
+        Extended Range Y, U, V three channels in one surface, interleaved as VUY. Only pitch linear format supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUVA_ER
+
+
+        Extended Range Y, U, V, A four channels in one surface, interleaved as AVUY.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_AYUV_ER
+
+
+        Extended Range Y, U, V, A four channels in one surface, interleaved as VUYA.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV444_PLANAR_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV422_PLANAR_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV444_SEMIPLANAR_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV422_SEMIPLANAR_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU444_PLANAR_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU422_PLANAR_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU444_SEMIPLANAR_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU422_SEMIPLANAR_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_RGGB
+
+
+        Bayer format - one channel in one surface with interleaved RGGB ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_BGGR
+
+
+        Bayer format - one channel in one surface with interleaved BGGR ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_GRBG
+
+
+        Bayer format - one channel in one surface with interleaved GRBG ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_GBRG
+
+
+        Bayer format - one channel in one surface with interleaved GBRG ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER10_RGGB
+
+
+        Bayer10 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER10_BGGR
+
+
+        Bayer10 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER10_GRBG
+
+
+        Bayer10 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER10_GBRG
+
+
+        Bayer10 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_RGGB
+
+
+        Bayer12 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_BGGR
+
+
+        Bayer12 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_GRBG
+
+
+        Bayer12 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_GBRG
+
+
+        Bayer12 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER14_RGGB
+
+
+        Bayer14 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER14_BGGR
+
+
+        Bayer14 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER14_GRBG
+
+
+        Bayer14 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER14_GBRG
+
+
+        Bayer14 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER20_RGGB
+
+
+        Bayer20 format - one channel in one surface with interleaved RGGB ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER20_BGGR
+
+
+        Bayer20 format - one channel in one surface with interleaved BGGR ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER20_GRBG
+
+
+        Bayer20 format - one channel in one surface with interleaved GRBG ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER20_GBRG
+
+
+        Bayer20 format - one channel in one surface with interleaved GBRG ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU444_PLANAR
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU422_PLANAR
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_PLANAR
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_ISP_RGGB
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved RGGB ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_ISP_BGGR
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved BGGR ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_ISP_GRBG
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved GRBG ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_ISP_GBRG
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved GBRG ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_BCCR
+
+
+        Bayer format - one channel in one surface with interleaved BCCR ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_RCCB
+
+
+        Bayer format - one channel in one surface with interleaved RCCB ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_CRBC
+
+
+        Bayer format - one channel in one surface with interleaved CRBC ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER_CBRC
+
+
+        Bayer format - one channel in one surface with interleaved CBRC ordering.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER10_CCCC
+
+
+        Bayer10 format - one channel in one surface with interleaved CCCC ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_BCCR
+
+
+        Bayer12 format - one channel in one surface with interleaved BCCR ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_RCCB
+
+
+        Bayer12 format - one channel in one surface with interleaved RCCB ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_CRBC
+
+
+        Bayer12 format - one channel in one surface with interleaved CRBC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_CBRC
+
+
+        Bayer12 format - one channel in one surface with interleaved CBRC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_BAYER12_CCCC
+
+
+        Bayer12 format - one channel in one surface with interleaved CCCC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y
+
+
+        Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_2020
+
+
+        Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_2020
+
+
+        Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_2020
+
+
+        Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V height= 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_2020
+
+
+        Y, V, U each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_SEMIPLANAR_709
+
+
+        Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_SEMIPLANAR_709
+
+
+        Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV420_PLANAR_709
+
+
+        Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVU420_PLANAR_709
+
+
+        Y, V, U each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709
+
+
+        Y10, V10U10 in two surfaces (VU as one surface), U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_2020
+
+
+        Y10, V10U10 in two surfaces (VU as one surface), U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_2020
+
+
+        Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR
+
+
+        Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_422_SEMIPLANAR_709
+
+
+        Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y_ER
+
+
+        Extended Range Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y_709_ER
+
+
+        Extended Range Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10_ER
+
+
+        Extended Range Color format for single Y10 plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10_709_ER
+
+
+        Extended Range Color format for single Y10 plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12_ER
+
+
+        Extended Range Color format for single Y12 plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12_709_ER
+
+
+        Extended Range Color format for single Y12 plane.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUVA
+
+
+        Y, U, V, A four channels in one surface, interleaved as AVUY.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YUV
+
+
+        Y, U, V three channels in one surface, interleaved as VUY. Only pitch linear format supported.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_YVYU
+
+
+        Y, U, V in one surface, interleaved as YVYU in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_VYUY
+
+
+        Y, U, V in one surface, interleaved as VYUY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_420_SEMIPLANAR_709_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces(VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y10V10U10_444_SEMIPLANAR_709_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_420_SEMIPLANAR_709_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_Y12V12U12_444_SEMIPLANAR_709_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.driver.CUeglColorFormat.CU_EGL_COLOR_FORMAT_MAX
+
+.. autoclass:: cuda.bindings.driver.CUdeviceptr_v2
+.. autoclass:: cuda.bindings.driver.CUdeviceptr
+.. autoclass:: cuda.bindings.driver.CUdevice_v1
+.. autoclass:: cuda.bindings.driver.CUdevice
+.. autoclass:: cuda.bindings.driver.CUcontext
+.. autoclass:: cuda.bindings.driver.CUmodule
+.. autoclass:: cuda.bindings.driver.CUfunction
+.. autoclass:: cuda.bindings.driver.CUarray
+.. autoclass:: cuda.bindings.driver.CUmipmappedArray
+.. autoclass:: cuda.bindings.driver.CUtexref
+.. autoclass:: cuda.bindings.driver.CUsurfref
+.. autoclass:: cuda.bindings.driver.CUevent
+.. autoclass:: cuda.bindings.driver.CUstream
+.. autoclass:: cuda.bindings.driver.CUgraphicsResource
+.. autoclass:: cuda.bindings.driver.CUtexObject_v1
+.. autoclass:: cuda.bindings.driver.CUtexObject
+.. autoclass:: cuda.bindings.driver.CUsurfObject_v1
+.. autoclass:: cuda.bindings.driver.CUsurfObject
+.. autoclass:: cuda.bindings.driver.CUexternalMemory
+.. autoclass:: cuda.bindings.driver.CUexternalSemaphore
+.. autoclass:: cuda.bindings.driver.CUgraph
+.. autoclass:: cuda.bindings.driver.CUgraphNode
+.. autoclass:: cuda.bindings.driver.CUgraphExec
+.. autoclass:: cuda.bindings.driver.CUmemoryPool
+.. autoclass:: cuda.bindings.driver.CUuserObject
+.. autoclass:: cuda.bindings.driver.CUuuid
+.. autoclass:: cuda.bindings.driver.CUipcEventHandle_v1
+.. autoclass:: cuda.bindings.driver.CUipcEventHandle
+.. autoclass:: cuda.bindings.driver.CUipcMemHandle_v1
+.. autoclass:: cuda.bindings.driver.CUipcMemHandle
+.. autoclass:: cuda.bindings.driver.CUstreamBatchMemOpParams_v1
+.. autoclass:: cuda.bindings.driver.CUstreamBatchMemOpParams
+.. autoclass:: cuda.bindings.driver.CUDA_BATCH_MEM_OP_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUdevprop_v1
+.. autoclass:: cuda.bindings.driver.CUdevprop
+.. autoclass:: cuda.bindings.driver.CUlinkState
+.. autoclass:: cuda.bindings.driver.CUhostFn
+.. autoclass:: cuda.bindings.driver.CUaccessPolicyWindow_v1
+.. autoclass:: cuda.bindings.driver.CUaccessPolicyWindow
+.. autoclass:: cuda.bindings.driver.CUDA_KERNEL_NODE_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_KERNEL_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_MEMSET_NODE_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_MEMSET_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_HOST_NODE_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_HOST_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUlaunchAttributeValue
+.. autoclass:: cuda.bindings.driver.CUlaunchAttribute
+.. autoclass:: cuda.bindings.driver.CUlaunchConfig
+.. autoclass:: cuda.bindings.driver.CUkernelNodeAttrID
+.. autoclass:: cuda.bindings.driver.CUkernelNodeAttrValue_v1
+.. autoclass:: cuda.bindings.driver.CUkernelNodeAttrValue
+.. autoclass:: cuda.bindings.driver.CUstreamAttrID
+.. autoclass:: cuda.bindings.driver.CUstreamAttrValue_v1
+.. autoclass:: cuda.bindings.driver.CUstreamAttrValue
+.. autoclass:: cuda.bindings.driver.CUexecAffinitySmCount_v1
+.. autoclass:: cuda.bindings.driver.CUexecAffinitySmCount
+.. autoclass:: cuda.bindings.driver.CUexecAffinityParam_v1
+.. autoclass:: cuda.bindings.driver.CUexecAffinityParam
+.. autoclass:: cuda.bindings.driver.CUstreamCallback
+.. autoclass:: cuda.bindings.driver.CUoccupancyB2DSize
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY2D_v2
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY2D
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_v2
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_PEER_v1
+.. autoclass:: cuda.bindings.driver.CUDA_MEMCPY3D_PEER
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_DESCRIPTOR_v2
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_DESCRIPTOR
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY3D_DESCRIPTOR_v2
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY3D_DESCRIPTOR
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_SPARSE_PROPERTIES_v1
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_SPARSE_PROPERTIES
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_MEMORY_REQUIREMENTS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_ARRAY_MEMORY_REQUIREMENTS
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_TEXTURE_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_TEXTURE_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_VIEW_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_RESOURCE_VIEW_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_POINTER_ATTRIBUTE_P2P_TOKENS
+.. autoclass:: cuda.bindings.driver.CUDA_LAUNCH_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_LAUNCH_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_HANDLE_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_BUFFER_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_SIGNAL_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_WAIT_NODE_PARAMS_v1
+.. autoclass:: cuda.bindings.driver.CUDA_EXT_SEM_WAIT_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUmemGenericAllocationHandle_v1
+.. autoclass:: cuda.bindings.driver.CUmemGenericAllocationHandle
+.. autoclass:: cuda.bindings.driver.CUarrayMapInfo_v1
+.. autoclass:: cuda.bindings.driver.CUarrayMapInfo
+.. autoclass:: cuda.bindings.driver.CUmemLocation_v1
+.. autoclass:: cuda.bindings.driver.CUmemLocation
+.. autoclass:: cuda.bindings.driver.CUmemAllocationProp_v1
+.. autoclass:: cuda.bindings.driver.CUmemAllocationProp
+.. autoclass:: cuda.bindings.driver.CUmemAccessDesc_v1
+.. autoclass:: cuda.bindings.driver.CUmemAccessDesc
+.. autoclass:: cuda.bindings.driver.CUmemPoolProps_v1
+.. autoclass:: cuda.bindings.driver.CUmemPoolProps
+.. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData_v1
+.. autoclass:: cuda.bindings.driver.CUmemPoolPtrExportData
+.. autoclass:: cuda.bindings.driver.CUDA_MEM_ALLOC_NODE_PARAMS
+.. autoclass:: cuda.bindings.driver.CUeglFrame_v1
+.. autoclass:: cuda.bindings.driver.CUeglFrame
+.. autoclass:: cuda.bindings.driver.CUeglStreamConnection
+.. autoattribute:: cuda.bindings.driver.CUDA_VERSION
+
+    CUDA API version number
+
+.. autoattribute:: cuda.bindings.driver.CU_UUID_HAS_BEEN_DEFINED
+
+    CUDA UUID types
+
+.. autoattribute:: cuda.bindings.driver.CU_IPC_HANDLE_SIZE
+
+    CUDA IPC handle size
+
+.. autoattribute:: cuda.bindings.driver.CU_STREAM_LEGACY
+
+    Legacy stream handle
+
+
+
+    Stream handle that can be passed as a CUstream to use an implicit stream with legacy synchronization behavior.
+
+
+
+    See details of the \link_sync_behavior
+
+.. autoattribute:: cuda.bindings.driver.CU_STREAM_PER_THREAD
+
+    Per-thread stream handle
+
+
+
+    Stream handle that can be passed as a CUstream to use an implicit stream with per-thread synchronization behavior.
+
+
+
+    See details of the \link_sync_behavior
+
+.. autoattribute:: cuda.bindings.driver.CUDA_CB
+.. autoattribute:: cuda.bindings.driver.CU_KERNEL_NODE_ATTRIBUTE_ACCESS_POLICY_WINDOW
+.. autoattribute:: cuda.bindings.driver.CU_KERNEL_NODE_ATTRIBUTE_COOPERATIVE
+.. autoattribute:: cuda.bindings.driver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_DIMENSION
+.. autoattribute:: cuda.bindings.driver.CU_KERNEL_NODE_ATTRIBUTE_CLUSTER_SCHEDULING_POLICY_PREFERENCE
+.. autoattribute:: cuda.bindings.driver.CU_KERNEL_NODE_ATTRIBUTE_PRIORITY
+.. autoattribute:: cuda.bindings.driver.CU_STREAM_ATTRIBUTE_ACCESS_POLICY_WINDOW
+.. autoattribute:: cuda.bindings.driver.CU_STREAM_ATTRIBUTE_SYNCHRONIZATION_POLICY
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTALLOC_PORTABLE
+
+    If set, host memory is portable between CUDA contexts. Flag for :py:obj:`~.cuMemHostAlloc()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTALLOC_DEVICEMAP
+
+    If set, host memory is mapped into CUDA address space and :py:obj:`~.cuMemHostGetDevicePointer()` may be called on the host pointer. Flag for :py:obj:`~.cuMemHostAlloc()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTALLOC_WRITECOMBINED
+
+    If set, host memory is allocated as write-combined - fast to write, faster to DMA, slow to read except via SSE4 streaming load instruction (MOVNTDQA). Flag for :py:obj:`~.cuMemHostAlloc()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTREGISTER_PORTABLE
+
+    If set, host memory is portable between CUDA contexts. Flag for :py:obj:`~.cuMemHostRegister()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTREGISTER_DEVICEMAP
+
+    If set, host memory is mapped into CUDA address space and :py:obj:`~.cuMemHostGetDevicePointer()` may be called on the host pointer. Flag for :py:obj:`~.cuMemHostRegister()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTREGISTER_IOMEMORY
+
+    If set, the passed memory pointer is treated as pointing to some memory-mapped I/O space, e.g. belonging to a third-party PCIe device. On Windows the flag is a no-op. On Linux that memory is marked as non cache-coherent for the GPU and is expected to be physically contiguous. It may return :py:obj:`~.CUDA_ERROR_NOT_PERMITTED` if run as an unprivileged user, :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` on older Linux kernel versions. On all other platforms, it is not supported and :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED` is returned. Flag for :py:obj:`~.cuMemHostRegister()`
+
+.. autoattribute:: cuda.bindings.driver.CU_MEMHOSTREGISTER_READ_ONLY
+
+    If set, the passed memory pointer is treated as pointing to memory that is considered read-only by the device. On platforms without :py:obj:`~.CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES`, this flag is required in order to register memory mapped to the CPU as read-only. Support for the use of this flag can be queried from the device attribute :py:obj:`~.CU_DEVICE_ATTRIBUTE_READ_ONLY_HOST_REGISTER_SUPPORTED`. Using this flag with a current context associated with a device that does not have this attribute set will cause :py:obj:`~.cuMemHostRegister` to error with :py:obj:`~.CUDA_ERROR_NOT_SUPPORTED`.
+
+.. autoattribute:: cuda.bindings.driver.CU_ARRAY_SPARSE_PROPERTIES_SINGLE_MIPTAIL
+
+    Indicates that the layered sparse CUDA array or CUDA mipmapped array has a single mip tail region for all layers
+
+.. autoattribute:: cuda.bindings.driver.CUDA_EXTERNAL_MEMORY_DEDICATED
+
+    Indicates that the external memory object is a dedicated resource
+
+.. autoattribute:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC
+
+    When the `flags` parameter of :py:obj:`~.CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS` contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as :py:obj:`~.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF`, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC
+
+    When the `flags` parameter of :py:obj:`~.CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS` contains this flag, it indicates that waiting on an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as :py:obj:`~.CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF`, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_NVSCISYNC_ATTR_SIGNAL
+
+    When `flags` of :py:obj:`~.cuDeviceGetNvSciSyncAttributes` is set to this, it indicates that application needs signaler specific NvSciSyncAttr to be filled by :py:obj:`~.cuDeviceGetNvSciSyncAttributes`.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_NVSCISYNC_ATTR_WAIT
+
+    When `flags` of :py:obj:`~.cuDeviceGetNvSciSyncAttributes` is set to this, it indicates that application needs waiter specific NvSciSyncAttr to be filled by :py:obj:`~.cuDeviceGetNvSciSyncAttributes`.
+
+.. autoattribute:: cuda.bindings.driver.CU_MEM_CREATE_USAGE_TILE_POOL
+
+    This flag if set indicates that the memory will be used as a tile pool.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
+
+    If set, each kernel launched as part of :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
+
+    If set, any subsequent work pushed in a stream that participated in a call to :py:obj:`~.cuLaunchCooperativeKernelMultiDevice` will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_LAYERED
+
+    If set, the CUDA array is a collection of layers, where each layer is either a 1D or a 2D array and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies the number of layers, not the depth of a 3D array.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_2DARRAY
+
+    Deprecated, use CUDA_ARRAY3D_LAYERED
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_SURFACE_LDST
+
+    This flag must be set in order to bind a surface reference to the CUDA array
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_CUBEMAP
+
+    If set, the CUDA array is a collection of six 2D arrays, representing faces of a cube. The width of such a CUDA array must be equal to its height, and Depth must be six. If :py:obj:`~.CUDA_ARRAY3D_LAYERED` flag is also set, then the CUDA array is a collection of cubemaps and Depth must be a multiple of six.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_TEXTURE_GATHER
+
+    This flag must be set in order to perform texture gather operations on a CUDA array.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_DEPTH_TEXTURE
+
+    This flag if set indicates that the CUDA array is a DEPTH_TEXTURE.
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_COLOR_ATTACHMENT
+
+    This flag indicates that the CUDA array may be bound as a color target in an external graphics API
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_SPARSE
+
+    This flag if set indicates that the CUDA array or CUDA mipmapped array is a sparse CUDA array or CUDA mipmapped array respectively
+
+.. autoattribute:: cuda.bindings.driver.CUDA_ARRAY3D_DEFERRED_MAPPING
+
+    This flag if set indicates that the CUDA array or CUDA mipmapped array will allow deferred memory mapping
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSA_OVERRIDE_FORMAT
+
+    Override the texref format with a format inferred from the array. Flag for :py:obj:`~.cuTexRefSetArray()`
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSF_READ_AS_INTEGER
+
+    Read the texture as integers rather than promoting the values to floats in the range [0,1]. Flag for :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSF_NORMALIZED_COORDINATES
+
+    Use normalized texture coordinates in the range [0,1) instead of [0,dim). Flag for :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSF_SRGB
+
+    Perform sRGB->linear conversion during texture read. Flag for :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
+
+    Disable any trilinear filtering optimizations. Flag for :py:obj:`~.cuTexRefSetFlags()` and :py:obj:`~.cuTexObjectCreate()`
+
+.. autoattribute:: cuda.bindings.driver.CU_TRSF_SEAMLESS_CUBEMAP
+
+    Enable seamless cube map filtering. Flag for :py:obj:`~.cuTexObjectCreate()`
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_END_AS_INT
+
+    C++ compile time constant for CU_LAUNCH_PARAM_END
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_END
+
+    End of array terminator for the `extra` parameter to :py:obj:`~.cuLaunchKernel`
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_BUFFER_POINTER_AS_INT
+
+    C++ compile time constant for CU_LAUNCH_PARAM_BUFFER_POINTER
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_BUFFER_POINTER
+
+    Indicator that the next value in the `extra` parameter to :py:obj:`~.cuLaunchKernel` will be a pointer to a buffer containing all kernel parameters used for launching kernel `f`. This buffer needs to honor all alignment/padding requirements of the individual parameters. If :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE` is not also specified in the `extra` array, then :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER` will have no effect.
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_BUFFER_SIZE_AS_INT
+
+    C++ compile time constant for CU_LAUNCH_PARAM_BUFFER_SIZE
+
+.. autoattribute:: cuda.bindings.driver.CU_LAUNCH_PARAM_BUFFER_SIZE
+
+    Indicator that the next value in the `extra` parameter to :py:obj:`~.cuLaunchKernel` will be a pointer to a size_t which contains the size of the buffer specified with :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER`. It is required that :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_POINTER` also be specified in the `extra` array if the value associated with :py:obj:`~.CU_LAUNCH_PARAM_BUFFER_SIZE` is not zero.
+
+.. autoattribute:: cuda.bindings.driver.CU_PARAM_TR_DEFAULT
+
+    For texture references loaded into the module, use default texunit from texture reference.
+
+.. autoattribute:: cuda.bindings.driver.CU_DEVICE_CPU
+
+    Device that represents the CPU
+
+.. autoattribute:: cuda.bindings.driver.CU_DEVICE_INVALID
+
+    Device that represents an invalid device
+
+.. autoattribute:: cuda.bindings.driver.MAX_PLANES
+
+    Maximum number of planes per frame
+
+.. autoattribute:: cuda.bindings.driver.CUDA_EGL_INFINITE_TIMEOUT
+
+    Indicates that timeout for :py:obj:`~.cuEGLStreamConsumerAcquireFrame` is infinite.
+
+
+Error Handling
+--------------
+
+This section describes the error handling functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuGetErrorString
+.. autofunction:: cuda.bindings.driver.cuGetErrorName
+
+Initialization
+--------------
+
+This section describes the initialization functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuInit
+
+Version Management
+------------------
+
+This section describes the version management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuDriverGetVersion
+
+Device Management
+-----------------
+
+This section describes the device management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuDeviceGet
+.. autofunction:: cuda.bindings.driver.cuDeviceGetCount
+.. autofunction:: cuda.bindings.driver.cuDeviceGetName
+.. autofunction:: cuda.bindings.driver.cuDeviceGetUuid
+.. autofunction:: cuda.bindings.driver.cuDeviceGetUuid_v2
+.. autofunction:: cuda.bindings.driver.cuDeviceGetLuid
+.. autofunction:: cuda.bindings.driver.cuDeviceTotalMem
+.. autofunction:: cuda.bindings.driver.cuDeviceGetTexture1DLinearMaxWidth
+.. autofunction:: cuda.bindings.driver.cuDeviceGetAttribute
+.. autofunction:: cuda.bindings.driver.cuDeviceGetNvSciSyncAttributes
+.. autofunction:: cuda.bindings.driver.cuDeviceSetMemPool
+.. autofunction:: cuda.bindings.driver.cuDeviceGetMemPool
+.. autofunction:: cuda.bindings.driver.cuDeviceGetDefaultMemPool
+.. autofunction:: cuda.bindings.driver.cuFlushGPUDirectRDMAWrites
+
+Primary Context Management
+--------------------------
+
+This section describes the primary context management functions of the low-level CUDA driver application programming interface.
+
+
+
+The primary context is unique per device and shared with the CUDA runtime API. These functions allow integration with other libraries using CUDA.
+
+.. autofunction:: cuda.bindings.driver.cuDevicePrimaryCtxRetain
+.. autofunction:: cuda.bindings.driver.cuDevicePrimaryCtxRelease
+.. autofunction:: cuda.bindings.driver.cuDevicePrimaryCtxSetFlags
+.. autofunction:: cuda.bindings.driver.cuDevicePrimaryCtxGetState
+.. autofunction:: cuda.bindings.driver.cuDevicePrimaryCtxReset
+
+Context Management
+------------------
+
+This section describes the context management functions of the low-level CUDA driver application programming interface.
+
+
+
+Please note that some functions are described in Primary Context Management section.
+
+.. autofunction:: cuda.bindings.driver.cuCtxCreate
+.. autofunction:: cuda.bindings.driver.cuCtxCreate_v3
+.. autofunction:: cuda.bindings.driver.cuCtxDestroy
+.. autofunction:: cuda.bindings.driver.cuCtxPushCurrent
+.. autofunction:: cuda.bindings.driver.cuCtxPopCurrent
+.. autofunction:: cuda.bindings.driver.cuCtxSetCurrent
+.. autofunction:: cuda.bindings.driver.cuCtxGetCurrent
+.. autofunction:: cuda.bindings.driver.cuCtxGetDevice
+.. autofunction:: cuda.bindings.driver.cuCtxGetFlags
+.. autofunction:: cuda.bindings.driver.cuCtxSynchronize
+.. autofunction:: cuda.bindings.driver.cuCtxSetLimit
+.. autofunction:: cuda.bindings.driver.cuCtxGetLimit
+.. autofunction:: cuda.bindings.driver.cuCtxGetCacheConfig
+.. autofunction:: cuda.bindings.driver.cuCtxSetCacheConfig
+.. autofunction:: cuda.bindings.driver.cuCtxGetSharedMemConfig
+.. autofunction:: cuda.bindings.driver.cuCtxSetSharedMemConfig
+.. autofunction:: cuda.bindings.driver.cuCtxGetApiVersion
+.. autofunction:: cuda.bindings.driver.cuCtxGetStreamPriorityRange
+.. autofunction:: cuda.bindings.driver.cuCtxResetPersistingL2Cache
+.. autofunction:: cuda.bindings.driver.cuCtxGetExecAffinity
+
+Module Management
+-----------------
+
+This section describes the module management functions of the low-level CUDA driver application programming interface.
+
+.. autoclass:: cuda.bindings.driver.CUmoduleLoadingMode
+
+    .. autoattribute:: cuda.bindings.driver.CUmoduleLoadingMode.CU_MODULE_EAGER_LOADING
+
+
+        Lazy Kernel Loading is not enabled
+
+
+    .. autoattribute:: cuda.bindings.driver.CUmoduleLoadingMode.CU_MODULE_LAZY_LOADING
+
+
+        Lazy Kernel Loading is enabled
+
+.. autofunction:: cuda.bindings.driver.cuModuleLoad
+.. autofunction:: cuda.bindings.driver.cuModuleLoadData
+.. autofunction:: cuda.bindings.driver.cuModuleLoadDataEx
+.. autofunction:: cuda.bindings.driver.cuModuleLoadFatBinary
+.. autofunction:: cuda.bindings.driver.cuModuleUnload
+.. autofunction:: cuda.bindings.driver.cuModuleGetLoadingMode
+.. autofunction:: cuda.bindings.driver.cuModuleGetFunction
+.. autofunction:: cuda.bindings.driver.cuModuleGetGlobal
+.. autofunction:: cuda.bindings.driver.cuModuleGetTexRef
+.. autofunction:: cuda.bindings.driver.cuModuleGetSurfRef
+.. autofunction:: cuda.bindings.driver.cuLinkCreate
+.. autofunction:: cuda.bindings.driver.cuLinkAddData
+.. autofunction:: cuda.bindings.driver.cuLinkAddFile
+.. autofunction:: cuda.bindings.driver.cuLinkComplete
+.. autofunction:: cuda.bindings.driver.cuLinkDestroy
+
+Memory Management
+-----------------
+
+This section describes the memory management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuMemGetInfo
+.. autofunction:: cuda.bindings.driver.cuMemAlloc
+.. autofunction:: cuda.bindings.driver.cuMemAllocPitch
+.. autofunction:: cuda.bindings.driver.cuMemFree
+.. autofunction:: cuda.bindings.driver.cuMemGetAddressRange
+.. autofunction:: cuda.bindings.driver.cuMemAllocHost
+.. autofunction:: cuda.bindings.driver.cuMemFreeHost
+.. autofunction:: cuda.bindings.driver.cuMemHostAlloc
+.. autofunction:: cuda.bindings.driver.cuMemHostGetDevicePointer
+.. autofunction:: cuda.bindings.driver.cuMemHostGetFlags
+.. autofunction:: cuda.bindings.driver.cuMemAllocManaged
+.. autofunction:: cuda.bindings.driver.cuDeviceGetByPCIBusId
+.. autofunction:: cuda.bindings.driver.cuDeviceGetPCIBusId
+.. autofunction:: cuda.bindings.driver.cuIpcGetEventHandle
+.. autofunction:: cuda.bindings.driver.cuIpcOpenEventHandle
+.. autofunction:: cuda.bindings.driver.cuIpcGetMemHandle
+.. autofunction:: cuda.bindings.driver.cuIpcOpenMemHandle
+.. autofunction:: cuda.bindings.driver.cuIpcCloseMemHandle
+.. autofunction:: cuda.bindings.driver.cuMemHostRegister
+.. autofunction:: cuda.bindings.driver.cuMemHostUnregister
+.. autofunction:: cuda.bindings.driver.cuMemcpy
+.. autofunction:: cuda.bindings.driver.cuMemcpyPeer
+.. autofunction:: cuda.bindings.driver.cuMemcpyHtoD
+.. autofunction:: cuda.bindings.driver.cuMemcpyDtoH
+.. autofunction:: cuda.bindings.driver.cuMemcpyDtoD
+.. autofunction:: cuda.bindings.driver.cuMemcpyDtoA
+.. autofunction:: cuda.bindings.driver.cuMemcpyAtoD
+.. autofunction:: cuda.bindings.driver.cuMemcpyHtoA
+.. autofunction:: cuda.bindings.driver.cuMemcpyAtoH
+.. autofunction:: cuda.bindings.driver.cuMemcpyAtoA
+.. autofunction:: cuda.bindings.driver.cuMemcpy2D
+.. autofunction:: cuda.bindings.driver.cuMemcpy2DUnaligned
+.. autofunction:: cuda.bindings.driver.cuMemcpy3D
+.. autofunction:: cuda.bindings.driver.cuMemcpy3DPeer
+.. autofunction:: cuda.bindings.driver.cuMemcpyAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyPeerAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyHtoDAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyDtoHAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyDtoDAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyHtoAAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpyAtoHAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpy2DAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpy3DAsync
+.. autofunction:: cuda.bindings.driver.cuMemcpy3DPeerAsync
+.. autofunction:: cuda.bindings.driver.cuMemsetD8
+.. autofunction:: cuda.bindings.driver.cuMemsetD16
+.. autofunction:: cuda.bindings.driver.cuMemsetD32
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D8
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D16
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D32
+.. autofunction:: cuda.bindings.driver.cuMemsetD8Async
+.. autofunction:: cuda.bindings.driver.cuMemsetD16Async
+.. autofunction:: cuda.bindings.driver.cuMemsetD32Async
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D8Async
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D16Async
+.. autofunction:: cuda.bindings.driver.cuMemsetD2D32Async
+.. autofunction:: cuda.bindings.driver.cuArrayCreate
+.. autofunction:: cuda.bindings.driver.cuArrayGetDescriptor
+.. autofunction:: cuda.bindings.driver.cuArrayGetSparseProperties
+.. autofunction:: cuda.bindings.driver.cuMipmappedArrayGetSparseProperties
+.. autofunction:: cuda.bindings.driver.cuArrayGetMemoryRequirements
+.. autofunction:: cuda.bindings.driver.cuMipmappedArrayGetMemoryRequirements
+.. autofunction:: cuda.bindings.driver.cuArrayGetPlane
+.. autofunction:: cuda.bindings.driver.cuArrayDestroy
+.. autofunction:: cuda.bindings.driver.cuArray3DCreate
+.. autofunction:: cuda.bindings.driver.cuArray3DGetDescriptor
+.. autofunction:: cuda.bindings.driver.cuMipmappedArrayCreate
+.. autofunction:: cuda.bindings.driver.cuMipmappedArrayGetLevel
+.. autofunction:: cuda.bindings.driver.cuMipmappedArrayDestroy
+.. autofunction:: cuda.bindings.driver.cuMemGetHandleForAddressRange
+
+Virtual Memory Management
+-------------------------
+
+This section describes the virtual memory management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuMemAddressReserve
+.. autofunction:: cuda.bindings.driver.cuMemAddressFree
+.. autofunction:: cuda.bindings.driver.cuMemCreate
+.. autofunction:: cuda.bindings.driver.cuMemRelease
+.. autofunction:: cuda.bindings.driver.cuMemMap
+.. autofunction:: cuda.bindings.driver.cuMemMapArrayAsync
+.. autofunction:: cuda.bindings.driver.cuMemUnmap
+.. autofunction:: cuda.bindings.driver.cuMemSetAccess
+.. autofunction:: cuda.bindings.driver.cuMemGetAccess
+.. autofunction:: cuda.bindings.driver.cuMemExportToShareableHandle
+.. autofunction:: cuda.bindings.driver.cuMemImportFromShareableHandle
+.. autofunction:: cuda.bindings.driver.cuMemGetAllocationGranularity
+.. autofunction:: cuda.bindings.driver.cuMemGetAllocationPropertiesFromHandle
+.. autofunction:: cuda.bindings.driver.cuMemRetainAllocationHandle
+
+Stream Ordered Memory Allocator
+-------------------------------
+
+This section describes the stream ordered memory allocator exposed by the low-level CUDA driver application programming interface.
+
+
+
+
+
+**overview**
+
+
+
+The asynchronous allocator allows the user to allocate and free in stream order. All asynchronous accesses of the allocation must happen between the stream executions of the allocation and the free. If the memory is accessed outside of the promised stream order, a use before allocation / use after free error will cause undefined behavior.
+
+The allocator is free to reallocate the memory as long as it can guarantee that compliant memory accesses will not overlap temporally. The allocator may refer to internal stream ordering as well as inter-stream dependencies (such as CUDA events and null stream dependencies) when establishing the temporal guarantee. The allocator may also insert inter-stream dependencies to establish the temporal guarantee.
+
+
+
+
+
+**Supported Platforms**
+
+
+
+Whether or not a device supports the integrated stream ordered memory allocator may be queried by calling cuDeviceGetAttribute() with the device attribute CU_DEVICE_ATTRIBUTE_MEMORY_POOLS_SUPPORTED
+
+.. autofunction:: cuda.bindings.driver.cuMemFreeAsync
+.. autofunction:: cuda.bindings.driver.cuMemAllocAsync
+.. autofunction:: cuda.bindings.driver.cuMemPoolTrimTo
+.. autofunction:: cuda.bindings.driver.cuMemPoolSetAttribute
+.. autofunction:: cuda.bindings.driver.cuMemPoolGetAttribute
+.. autofunction:: cuda.bindings.driver.cuMemPoolSetAccess
+.. autofunction:: cuda.bindings.driver.cuMemPoolGetAccess
+.. autofunction:: cuda.bindings.driver.cuMemPoolCreate
+.. autofunction:: cuda.bindings.driver.cuMemPoolDestroy
+.. autofunction:: cuda.bindings.driver.cuMemAllocFromPoolAsync
+.. autofunction:: cuda.bindings.driver.cuMemPoolExportToShareableHandle
+.. autofunction:: cuda.bindings.driver.cuMemPoolImportFromShareableHandle
+.. autofunction:: cuda.bindings.driver.cuMemPoolExportPointer
+.. autofunction:: cuda.bindings.driver.cuMemPoolImportPointer
+
+Unified Addressing
+------------------
+
+This section describes the unified addressing functions of the low-level CUDA driver application programming interface.
+
+
+
+
+
+**Overview**
+
+
+
+CUDA devices can share a unified address space with the host. For these devices there is no distinction between a device pointer and a host pointer -- the same pointer value may be used to access memory from the host program and from a kernel running on the device (with exceptions enumerated below).
+
+
+
+
+
+**Supported Platforms**
+
+
+
+Whether or not a device supports unified addressing may be queried by calling cuDeviceGetAttribute() with the device attribute CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING.
+
+Unified addressing is automatically enabled in 64-bit processes
+
+
+
+
+
+**Looking Up Information from Pointer Values**
+
+
+
+It is possible to look up information about the memory which backs a pointer value. For instance, one may want to know if a pointer points to host or device memory. As another example, in the case of device memory, one may want to know on which CUDA device the memory resides. These properties may be queried using the function cuPointerGetAttribute()
+
+Since pointers are unique, it is not necessary to specify information about the pointers specified to the various copy functions in the CUDA API. The function cuMemcpy() may be used to perform a copy between two pointers, ignoring whether they point to host or device memory (making cuMemcpyHtoD(), cuMemcpyDtoD(), and cuMemcpyDtoH() unnecessary for devices supporting unified addressing). For multidimensional copies, the memory type CU_MEMORYTYPE_UNIFIED may be used to specify that the CUDA driver should infer the location of the pointer from its value.
+
+
+
+
+
+**Automatic Mapping of Host Allocated Host Memory**
+
+
+
+All host memory allocated in all contexts using cuMemAllocHost() and cuMemHostAlloc() is always directly accessible from all contexts on all devices that support unified addressing. This is the case regardless of whether or not the flags CU_MEMHOSTALLOC_PORTABLE and CU_MEMHOSTALLOC_DEVICEMAP are specified.
+
+The pointer value through which allocated host memory may be accessed in kernels on all devices that support unified addressing is the same as the pointer value through which that memory is accessed on the host, so it is not necessary to call cuMemHostGetDevicePointer() to get the device pointer for these allocations.
+
+Note that this is not the case for memory allocated using the flag CU_MEMHOSTALLOC_WRITECOMBINED, as discussed below.
+
+
+
+
+
+**Automatic Registration of Peer Memory**
+
+
+
+Upon enabling direct access from a context that supports unified addressing to another peer context that supports unified addressing using cuCtxEnablePeerAccess() all memory allocated in the peer context using cuMemAlloc() and cuMemAllocPitch() will immediately be accessible by the current context. The device pointer value through which any peer memory may be accessed in the current context is the same pointer value through which that memory may be accessed in the peer context.
+
+
+
+
+
+**Exceptions, Disjoint Addressing**
+
+
+
+Not all memory may be accessed on devices through the same pointer value through which they are accessed on the host. These exceptions are host memory registered using cuMemHostRegister() and host memory allocated using the flag CU_MEMHOSTALLOC_WRITECOMBINED. For these exceptions, there exists a distinct host and device address for the memory. The device address is guaranteed to not overlap any valid host pointer range and is guaranteed to have the same value across all contexts that support unified addressing.
+
+This device address may be queried using cuMemHostGetDevicePointer() when a context using unified addressing is current. Either the host or the unified device pointer value may be used to refer to this memory through cuMemcpy() and similar functions using the CU_MEMORYTYPE_UNIFIED memory type.
+
+.. autofunction:: cuda.bindings.driver.cuPointerGetAttribute
+.. autofunction:: cuda.bindings.driver.cuMemPrefetchAsync
+.. autofunction:: cuda.bindings.driver.cuMemAdvise
+.. autofunction:: cuda.bindings.driver.cuMemRangeGetAttribute
+.. autofunction:: cuda.bindings.driver.cuMemRangeGetAttributes
+.. autofunction:: cuda.bindings.driver.cuPointerSetAttribute
+.. autofunction:: cuda.bindings.driver.cuPointerGetAttributes
+
+Stream Management
+-----------------
+
+This section describes the stream management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuStreamCreate
+.. autofunction:: cuda.bindings.driver.cuStreamCreateWithPriority
+.. autofunction:: cuda.bindings.driver.cuStreamGetPriority
+.. autofunction:: cuda.bindings.driver.cuStreamGetFlags
+.. autofunction:: cuda.bindings.driver.cuStreamGetCtx
+.. autofunction:: cuda.bindings.driver.cuStreamWaitEvent
+.. autofunction:: cuda.bindings.driver.cuStreamAddCallback
+.. autofunction:: cuda.bindings.driver.cuStreamBeginCapture
+.. autofunction:: cuda.bindings.driver.cuThreadExchangeStreamCaptureMode
+.. autofunction:: cuda.bindings.driver.cuStreamEndCapture
+.. autofunction:: cuda.bindings.driver.cuStreamIsCapturing
+.. autofunction:: cuda.bindings.driver.cuStreamGetCaptureInfo
+.. autofunction:: cuda.bindings.driver.cuStreamGetCaptureInfo_v2
+.. autofunction:: cuda.bindings.driver.cuStreamUpdateCaptureDependencies
+.. autofunction:: cuda.bindings.driver.cuStreamAttachMemAsync
+.. autofunction:: cuda.bindings.driver.cuStreamQuery
+.. autofunction:: cuda.bindings.driver.cuStreamSynchronize
+.. autofunction:: cuda.bindings.driver.cuStreamDestroy
+.. autofunction:: cuda.bindings.driver.cuStreamCopyAttributes
+.. autofunction:: cuda.bindings.driver.cuStreamGetAttribute
+.. autofunction:: cuda.bindings.driver.cuStreamSetAttribute
+
+Event Management
+----------------
+
+This section describes the event management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuEventCreate
+.. autofunction:: cuda.bindings.driver.cuEventRecord
+.. autofunction:: cuda.bindings.driver.cuEventRecordWithFlags
+.. autofunction:: cuda.bindings.driver.cuEventQuery
+.. autofunction:: cuda.bindings.driver.cuEventSynchronize
+.. autofunction:: cuda.bindings.driver.cuEventDestroy
+.. autofunction:: cuda.bindings.driver.cuEventElapsedTime
+
+External Resource Interoperability
+----------------------------------
+
+This section describes the external resource interoperability functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuImportExternalMemory
+.. autofunction:: cuda.bindings.driver.cuExternalMemoryGetMappedBuffer
+.. autofunction:: cuda.bindings.driver.cuExternalMemoryGetMappedMipmappedArray
+.. autofunction:: cuda.bindings.driver.cuDestroyExternalMemory
+.. autofunction:: cuda.bindings.driver.cuImportExternalSemaphore
+.. autofunction:: cuda.bindings.driver.cuSignalExternalSemaphoresAsync
+.. autofunction:: cuda.bindings.driver.cuWaitExternalSemaphoresAsync
+.. autofunction:: cuda.bindings.driver.cuDestroyExternalSemaphore
+
+Stream Memory Operations
+------------------------
+
+This section describes the stream memory operations of the low-level CUDA driver application programming interface.
+
+
+
+There are two versions of these APIs, a legacy version and a newer V2 version.
+
+
+
+V1:
+
+
+
+The V1 API is disabled by default. Users are required to explicitly enable it, e.g. on Linux by passing the kernel module parameter shown below: modprobe nvidia NVreg_EnableStreamMemOPs=1 There is currently no way to enable these operations on other operating systems.
+
+
+
+Users can programmatically query whether the device supports these operations with cuDeviceGetAttribute() and CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS.
+
+
+
+Support for the CU_STREAM_WAIT_VALUE_NOR flag can be queried with CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR.
+
+
+
+Support for the cuStreamWriteValue64() and cuStreamWaitValue64() functions, as well as for the CU_STREAM_MEM_OP_WAIT_VALUE_64 and CU_STREAM_MEM_OP_WRITE_VALUE_64 flags, can be queried with CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS.
+
+
+
+Support for both CU_STREAM_WAIT_VALUE_FLUSH and CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES requires dedicated platform hardware features and can be queried with cuDeviceGetAttribute() and CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES.
+
+
+
+V2:
+
+
+
+The V2 APIs are available by default on all platforms.
+
+
+
+Support for the CU_STREAM_WAIT_VALUE_NOR flag can be queried with CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR_V2.
+
+
+
+Support for the cuStreamWriteValue64() and cuStreamWaitValue64() functions, as well as for the CU_STREAM_MEM_OP_WAIT_VALUE_64 and CU_STREAM_MEM_OP_WRITE_VALUE_64 flags, can be queried with CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS_V2.
+
+
+
+Support for both CU_STREAM_WAIT_VALUE_FLUSH and CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES requires dedicated platform hardware features and can be queried with cuDeviceGetAttribute() and CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES.
+
+
+
+V1 & V2:
+
+
+
+Note that all memory pointers passed as parameters to these operations are device pointers. Where necessary a device pointer should be obtained, for example with cuMemHostGetDevicePointer().
+
+
+
+None of the operations accepts pointers to managed memory buffers (cuMemAllocManaged).
+
+
+
+Warning: Improper use of these APIs may deadlock the application. Synchronization ordering established through these APIs is not visible to CUDA. CUDA tasks that are (even indirectly) ordered by these APIs should also have that order expressed with CUDA-visible dependencies such as events. This ensures that the scheduler does not serialize them in an improper order.
+
+.. autofunction:: cuda.bindings.driver.cuStreamWaitValue32
+.. autofunction:: cuda.bindings.driver.cuStreamWaitValue64
+.. autofunction:: cuda.bindings.driver.cuStreamWriteValue32
+.. autofunction:: cuda.bindings.driver.cuStreamWriteValue64
+.. autofunction:: cuda.bindings.driver.cuStreamBatchMemOp
+.. autofunction:: cuda.bindings.driver.cuStreamWaitValue32_v2
+.. autofunction:: cuda.bindings.driver.cuStreamWaitValue64_v2
+.. autofunction:: cuda.bindings.driver.cuStreamWriteValue32_v2
+.. autofunction:: cuda.bindings.driver.cuStreamWriteValue64_v2
+.. autofunction:: cuda.bindings.driver.cuStreamBatchMemOp_v2
+
+Execution Control
+-----------------
+
+This section describes the execution control functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuFuncGetAttribute
+.. autofunction:: cuda.bindings.driver.cuFuncSetAttribute
+.. autofunction:: cuda.bindings.driver.cuFuncSetCacheConfig
+.. autofunction:: cuda.bindings.driver.cuFuncSetSharedMemConfig
+.. autofunction:: cuda.bindings.driver.cuFuncGetModule
+.. autofunction:: cuda.bindings.driver.cuLaunchKernel
+.. autofunction:: cuda.bindings.driver.cuLaunchKernelEx
+.. autofunction:: cuda.bindings.driver.cuLaunchCooperativeKernel
+.. autofunction:: cuda.bindings.driver.cuLaunchCooperativeKernelMultiDevice
+.. autofunction:: cuda.bindings.driver.cuLaunchHostFunc
+
+Graph Management
+----------------
+
+This section describes the graph management functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuGraphCreate
+.. autofunction:: cuda.bindings.driver.cuGraphAddKernelNode
+.. autofunction:: cuda.bindings.driver.cuGraphKernelNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphKernelNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddMemcpyNode
+.. autofunction:: cuda.bindings.driver.cuGraphMemcpyNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphMemcpyNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddMemsetNode
+.. autofunction:: cuda.bindings.driver.cuGraphMemsetNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphMemsetNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddHostNode
+.. autofunction:: cuda.bindings.driver.cuGraphHostNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphHostNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddChildGraphNode
+.. autofunction:: cuda.bindings.driver.cuGraphChildGraphNodeGetGraph
+.. autofunction:: cuda.bindings.driver.cuGraphAddEmptyNode
+.. autofunction:: cuda.bindings.driver.cuGraphAddEventRecordNode
+.. autofunction:: cuda.bindings.driver.cuGraphEventRecordNodeGetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphEventRecordNodeSetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphAddEventWaitNode
+.. autofunction:: cuda.bindings.driver.cuGraphEventWaitNodeGetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphEventWaitNodeSetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphAddExternalSemaphoresSignalNode
+.. autofunction:: cuda.bindings.driver.cuGraphExternalSemaphoresSignalNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExternalSemaphoresSignalNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddExternalSemaphoresWaitNode
+.. autofunction:: cuda.bindings.driver.cuGraphExternalSemaphoresWaitNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExternalSemaphoresWaitNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddBatchMemOpNode
+.. autofunction:: cuda.bindings.driver.cuGraphBatchMemOpNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphBatchMemOpNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecBatchMemOpNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddMemAllocNode
+.. autofunction:: cuda.bindings.driver.cuGraphMemAllocNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuGraphAddMemFreeNode
+.. autofunction:: cuda.bindings.driver.cuGraphMemFreeNodeGetParams
+.. autofunction:: cuda.bindings.driver.cuDeviceGraphMemTrim
+.. autofunction:: cuda.bindings.driver.cuDeviceGetGraphMemAttribute
+.. autofunction:: cuda.bindings.driver.cuDeviceSetGraphMemAttribute
+.. autofunction:: cuda.bindings.driver.cuGraphClone
+.. autofunction:: cuda.bindings.driver.cuGraphNodeFindInClone
+.. autofunction:: cuda.bindings.driver.cuGraphNodeGetType
+.. autofunction:: cuda.bindings.driver.cuGraphGetNodes
+.. autofunction:: cuda.bindings.driver.cuGraphGetRootNodes
+.. autofunction:: cuda.bindings.driver.cuGraphGetEdges
+.. autofunction:: cuda.bindings.driver.cuGraphNodeGetDependencies
+.. autofunction:: cuda.bindings.driver.cuGraphNodeGetDependentNodes
+.. autofunction:: cuda.bindings.driver.cuGraphAddDependencies
+.. autofunction:: cuda.bindings.driver.cuGraphRemoveDependencies
+.. autofunction:: cuda.bindings.driver.cuGraphDestroyNode
+.. autofunction:: cuda.bindings.driver.cuGraphInstantiate
+.. autofunction:: cuda.bindings.driver.cuGraphInstantiateWithFlags
+.. autofunction:: cuda.bindings.driver.cuGraphExecKernelNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecMemcpyNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecMemsetNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecHostNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecChildGraphNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecEventRecordNodeSetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphExecEventWaitNodeSetEvent
+.. autofunction:: cuda.bindings.driver.cuGraphExecExternalSemaphoresSignalNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphExecExternalSemaphoresWaitNodeSetParams
+.. autofunction:: cuda.bindings.driver.cuGraphNodeSetEnabled
+.. autofunction:: cuda.bindings.driver.cuGraphNodeGetEnabled
+.. autofunction:: cuda.bindings.driver.cuGraphUpload
+.. autofunction:: cuda.bindings.driver.cuGraphLaunch
+.. autofunction:: cuda.bindings.driver.cuGraphExecDestroy
+.. autofunction:: cuda.bindings.driver.cuGraphDestroy
+.. autofunction:: cuda.bindings.driver.cuGraphExecUpdate
+.. autofunction:: cuda.bindings.driver.cuGraphKernelNodeCopyAttributes
+.. autofunction:: cuda.bindings.driver.cuGraphKernelNodeGetAttribute
+.. autofunction:: cuda.bindings.driver.cuGraphKernelNodeSetAttribute
+.. autofunction:: cuda.bindings.driver.cuGraphDebugDotPrint
+.. autofunction:: cuda.bindings.driver.cuUserObjectCreate
+.. autofunction:: cuda.bindings.driver.cuUserObjectRetain
+.. autofunction:: cuda.bindings.driver.cuUserObjectRelease
+.. autofunction:: cuda.bindings.driver.cuGraphRetainUserObject
+.. autofunction:: cuda.bindings.driver.cuGraphReleaseUserObject
+
+Occupancy
+---------
+
+This section describes the occupancy calculation functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxActiveBlocksPerMultiprocessor
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxPotentialBlockSize
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxPotentialBlockSizeWithFlags
+.. autofunction:: cuda.bindings.driver.cuOccupancyAvailableDynamicSMemPerBlock
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxPotentialClusterSize
+.. autofunction:: cuda.bindings.driver.cuOccupancyMaxActiveClusters
+
+Texture Object Management
+-------------------------
+
+This section describes the texture object management functions of the low-level CUDA driver application programming interface. The texture object API is only supported on devices of compute capability 3.0 or higher.
+
+.. autofunction:: cuda.bindings.driver.cuTexObjectCreate
+.. autofunction:: cuda.bindings.driver.cuTexObjectDestroy
+.. autofunction:: cuda.bindings.driver.cuTexObjectGetResourceDesc
+.. autofunction:: cuda.bindings.driver.cuTexObjectGetTextureDesc
+.. autofunction:: cuda.bindings.driver.cuTexObjectGetResourceViewDesc
+
+Surface Object Management
+-------------------------
+
+This section describes the surface object management functions of the low-level CUDA driver application programming interface. The surface object API is only supported on devices of compute capability 3.0 or higher.
+
+.. autofunction:: cuda.bindings.driver.cuSurfObjectCreate
+.. autofunction:: cuda.bindings.driver.cuSurfObjectDestroy
+.. autofunction:: cuda.bindings.driver.cuSurfObjectGetResourceDesc
+
+Peer Context Memory Access
+--------------------------
+
+This section describes the direct peer context memory access functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuDeviceCanAccessPeer
+.. autofunction:: cuda.bindings.driver.cuCtxEnablePeerAccess
+.. autofunction:: cuda.bindings.driver.cuCtxDisablePeerAccess
+.. autofunction:: cuda.bindings.driver.cuDeviceGetP2PAttribute
+
+Graphics Interoperability
+-------------------------
+
+This section describes the graphics interoperability functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuGraphicsUnregisterResource
+.. autofunction:: cuda.bindings.driver.cuGraphicsSubResourceGetMappedArray
+.. autofunction:: cuda.bindings.driver.cuGraphicsResourceGetMappedMipmappedArray
+.. autofunction:: cuda.bindings.driver.cuGraphicsResourceGetMappedPointer
+.. autofunction:: cuda.bindings.driver.cuGraphicsResourceSetMapFlags
+.. autofunction:: cuda.bindings.driver.cuGraphicsMapResources
+.. autofunction:: cuda.bindings.driver.cuGraphicsUnmapResources
+
+Driver Entry Point Access
+-------------------------
+
+This section describes the driver entry point access functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuGetProcAddress
+
+EGL Interoperability
+--------------------
+
+This section describes the EGL interoperability functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuGraphicsEGLRegisterImage
+.. autofunction:: cuda.bindings.driver.cuEGLStreamConsumerConnect
+.. autofunction:: cuda.bindings.driver.cuEGLStreamConsumerConnectWithFlags
+.. autofunction:: cuda.bindings.driver.cuEGLStreamConsumerDisconnect
+.. autofunction:: cuda.bindings.driver.cuEGLStreamConsumerAcquireFrame
+.. autofunction:: cuda.bindings.driver.cuEGLStreamConsumerReleaseFrame
+.. autofunction:: cuda.bindings.driver.cuEGLStreamProducerConnect
+.. autofunction:: cuda.bindings.driver.cuEGLStreamProducerDisconnect
+.. autofunction:: cuda.bindings.driver.cuEGLStreamProducerPresentFrame
+.. autofunction:: cuda.bindings.driver.cuEGLStreamProducerReturnFrame
+.. autofunction:: cuda.bindings.driver.cuGraphicsResourceGetMappedEglFrame
+.. autofunction:: cuda.bindings.driver.cuEventCreateFromEGLSync
+
+OpenGL Interoperability
+-----------------------
+
+This section describes the OpenGL interoperability functions of the low-level CUDA driver application programming interface. Note that mapping of OpenGL resources is performed with the graphics API agnostic, resource mapping interface described in Graphics Interoperability.
+
+.. autoclass:: cuda.bindings.driver.CUGLDeviceList
+
+    .. autoattribute:: cuda.bindings.driver.CUGLDeviceList.CU_GL_DEVICE_LIST_ALL
+
+
+        The CUDA devices for all GPUs used by the current OpenGL context
+
+
+    .. autoattribute:: cuda.bindings.driver.CUGLDeviceList.CU_GL_DEVICE_LIST_CURRENT_FRAME
+
+
+        The CUDA devices for the GPUs used by the current OpenGL context in its currently rendering frame
+
+
+    .. autoattribute:: cuda.bindings.driver.CUGLDeviceList.CU_GL_DEVICE_LIST_NEXT_FRAME
+
+
+        The CUDA devices for the GPUs to be used by the current OpenGL context in the next frame
+
+.. autofunction:: cuda.bindings.driver.cuGraphicsGLRegisterBuffer
+.. autofunction:: cuda.bindings.driver.cuGraphicsGLRegisterImage
+.. autofunction:: cuda.bindings.driver.cuGLGetDevices
+
+Profiler Control
+----------------
+
+This section describes the profiler control functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuProfilerStart
+.. autofunction:: cuda.bindings.driver.cuProfilerStop
+
+VDPAU Interoperability
+----------------------
+
+This section describes the VDPAU interoperability functions of the low-level CUDA driver application programming interface.
+
+.. autofunction:: cuda.bindings.driver.cuVDPAUGetDevice
+.. autofunction:: cuda.bindings.driver.cuVDPAUCtxCreate
+.. autofunction:: cuda.bindings.driver.cuGraphicsVDPAURegisterVideoSurface
+.. autofunction:: cuda.bindings.driver.cuGraphicsVDPAURegisterOutputSurface
diff --git a/docs_src/source/module/nvrtc.rst b/docs_src/source/module/nvrtc.rst
index 16dfa9ff..9c031b2d 100644
--- a/docs_src/source/module/nvrtc.rst
+++ b/docs_src/source/module/nvrtc.rst
@@ -7,73 +7,73 @@ Error Handling
 
 NVRTC defines the following enumeration type and function for API call error handling.
 
-.. autoclass:: cuda.nvrtc.nvrtcResult
+.. autoclass:: cuda.bindings.nvrtc.nvrtcResult
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_SUCCESS
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_SUCCESS
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_OUT_OF_MEMORY
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_OUT_OF_MEMORY
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_PROGRAM_CREATION_FAILURE
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_PROGRAM_CREATION_FAILURE
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_INPUT
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_INPUT
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_PROGRAM
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_PROGRAM
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_OPTION
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_INVALID_OPTION
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_COMPILATION
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_COMPILATION
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_BUILTIN_OPERATION_FAILURE
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_NO_NAME_EXPRESSIONS_AFTER_COMPILATION
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_NO_LOWERED_NAMES_BEFORE_COMPILATION
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_NAME_EXPRESSION_NOT_VALID
 
 
-    .. autoattribute:: cuda.nvrtc.nvrtcResult.NVRTC_ERROR_INTERNAL_ERROR
+    .. autoattribute:: cuda.bindings.nvrtc.nvrtcResult.NVRTC_ERROR_INTERNAL_ERROR
 
-.. autofunction:: cuda.nvrtc.nvrtcGetErrorString
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetErrorString
 
 General Information Query
 -------------------------
 
 NVRTC defines the following function for general information query.
 
-.. autofunction:: cuda.nvrtc.nvrtcVersion
-.. autofunction:: cuda.nvrtc.nvrtcGetNumSupportedArchs
-.. autofunction:: cuda.nvrtc.nvrtcGetSupportedArchs
+.. autofunction:: cuda.bindings.nvrtc.nvrtcVersion
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetNumSupportedArchs
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetSupportedArchs
 
 Compilation
 -----------
 
 NVRTC defines the following type and functions for actual compilation.
 
-.. autoclass:: cuda.nvrtc.nvrtcProgram
-.. autofunction:: cuda.nvrtc.nvrtcCreateProgram
-.. autofunction:: cuda.nvrtc.nvrtcDestroyProgram
-.. autofunction:: cuda.nvrtc.nvrtcCompileProgram
-.. autofunction:: cuda.nvrtc.nvrtcGetPTXSize
-.. autofunction:: cuda.nvrtc.nvrtcGetPTX
-.. autofunction:: cuda.nvrtc.nvrtcGetCUBINSize
-.. autofunction:: cuda.nvrtc.nvrtcGetCUBIN
-.. autofunction:: cuda.nvrtc.nvrtcGetNVVMSize
-.. autofunction:: cuda.nvrtc.nvrtcGetNVVM
-.. autofunction:: cuda.nvrtc.nvrtcGetProgramLogSize
-.. autofunction:: cuda.nvrtc.nvrtcGetProgramLog
-.. autofunction:: cuda.nvrtc.nvrtcAddNameExpression
-.. autofunction:: cuda.nvrtc.nvrtcGetLoweredName
+.. autoclass:: cuda.bindings.nvrtc.nvrtcProgram
+.. autofunction:: cuda.bindings.nvrtc.nvrtcCreateProgram
+.. autofunction:: cuda.bindings.nvrtc.nvrtcDestroyProgram
+.. autofunction:: cuda.bindings.nvrtc.nvrtcCompileProgram
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetPTXSize
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetPTX
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetCUBINSize
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetCUBIN
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetNVVMSize
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetNVVM
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetProgramLogSize
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetProgramLog
+.. autofunction:: cuda.bindings.nvrtc.nvrtcAddNameExpression
+.. autofunction:: cuda.bindings.nvrtc.nvrtcGetLoweredName
 
 Supported Compile Options
 -------------------------
diff --git a/docs_src/source/module/runtime.rst b/docs_src/source/module/runtime.rst
new file mode 100644
index 00000000..c4660754
--- /dev/null
+++ b/docs_src/source/module/runtime.rst
@@ -0,0 +1,4837 @@
+-------
+runtime
+-------
+
+Profiler Control
+----------------
+
+This section describes the profiler control functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaProfilerStart
+.. autofunction:: cuda.bindings.runtime.cudaProfilerStop
+
+Device Management
+-----------------
+
+impl_private
+
+
+
+
+
+
+
+This section describes the device management functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaDeviceReset
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSynchronize
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSetLimit
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetLimit
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetTexture1DLinearMaxWidth
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetCacheConfig
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetStreamPriorityRange
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSetCacheConfig
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetSharedMemConfig
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSetSharedMemConfig
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetByPCIBusId
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetPCIBusId
+.. autofunction:: cuda.bindings.runtime.cudaIpcGetEventHandle
+.. autofunction:: cuda.bindings.runtime.cudaIpcOpenEventHandle
+.. autofunction:: cuda.bindings.runtime.cudaIpcGetMemHandle
+.. autofunction:: cuda.bindings.runtime.cudaIpcOpenMemHandle
+.. autofunction:: cuda.bindings.runtime.cudaIpcCloseMemHandle
+.. autofunction:: cuda.bindings.runtime.cudaDeviceFlushGPUDirectRDMAWrites
+.. autofunction:: cuda.bindings.runtime.cudaGetDeviceCount
+.. autofunction:: cuda.bindings.runtime.cudaGetDeviceProperties
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetDefaultMemPool
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSetMemPool
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetMemPool
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetNvSciSyncAttributes
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetP2PAttribute
+.. autofunction:: cuda.bindings.runtime.cudaChooseDevice
+.. autofunction:: cuda.bindings.runtime.cudaSetDevice
+.. autofunction:: cuda.bindings.runtime.cudaGetDevice
+.. autofunction:: cuda.bindings.runtime.cudaSetDeviceFlags
+.. autofunction:: cuda.bindings.runtime.cudaGetDeviceFlags
+
+Error Handling
+--------------
+
+This section describes the error handling functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaGetLastError
+.. autofunction:: cuda.bindings.runtime.cudaPeekAtLastError
+.. autofunction:: cuda.bindings.runtime.cudaGetErrorName
+.. autofunction:: cuda.bindings.runtime.cudaGetErrorString
+
+Stream Management
+-----------------
+
+This section describes the stream management functions of the CUDA runtime application programming interface.
+
+.. autoclass:: cuda.bindings.runtime.cudaStreamCallback_t
+.. autofunction:: cuda.bindings.runtime.cudaStreamCreate
+.. autofunction:: cuda.bindings.runtime.cudaStreamCreateWithFlags
+.. autofunction:: cuda.bindings.runtime.cudaStreamCreateWithPriority
+.. autofunction:: cuda.bindings.runtime.cudaStreamGetPriority
+.. autofunction:: cuda.bindings.runtime.cudaStreamGetFlags
+.. autofunction:: cuda.bindings.runtime.cudaCtxResetPersistingL2Cache
+.. autofunction:: cuda.bindings.runtime.cudaStreamCopyAttributes
+.. autofunction:: cuda.bindings.runtime.cudaStreamGetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaStreamSetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaStreamDestroy
+.. autofunction:: cuda.bindings.runtime.cudaStreamWaitEvent
+.. autofunction:: cuda.bindings.runtime.cudaStreamAddCallback
+.. autofunction:: cuda.bindings.runtime.cudaStreamSynchronize
+.. autofunction:: cuda.bindings.runtime.cudaStreamQuery
+.. autofunction:: cuda.bindings.runtime.cudaStreamAttachMemAsync
+.. autofunction:: cuda.bindings.runtime.cudaStreamBeginCapture
+.. autofunction:: cuda.bindings.runtime.cudaThreadExchangeStreamCaptureMode
+.. autofunction:: cuda.bindings.runtime.cudaStreamEndCapture
+.. autofunction:: cuda.bindings.runtime.cudaStreamIsCapturing
+.. autofunction:: cuda.bindings.runtime.cudaStreamGetCaptureInfo
+.. autofunction:: cuda.bindings.runtime.cudaStreamGetCaptureInfo_v2
+.. autofunction:: cuda.bindings.runtime.cudaStreamUpdateCaptureDependencies
+
+Event Management
+----------------
+
+This section describes the event management functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaEventCreate
+.. autofunction:: cuda.bindings.runtime.cudaEventCreateWithFlags
+.. autofunction:: cuda.bindings.runtime.cudaEventRecord
+.. autofunction:: cuda.bindings.runtime.cudaEventRecordWithFlags
+.. autofunction:: cuda.bindings.runtime.cudaEventQuery
+.. autofunction:: cuda.bindings.runtime.cudaEventSynchronize
+.. autofunction:: cuda.bindings.runtime.cudaEventDestroy
+.. autofunction:: cuda.bindings.runtime.cudaEventElapsedTime
+
+External Resource Interoperability
+----------------------------------
+
+This section describes the external resource interoperability functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaImportExternalMemory
+.. autofunction:: cuda.bindings.runtime.cudaExternalMemoryGetMappedBuffer
+.. autofunction:: cuda.bindings.runtime.cudaExternalMemoryGetMappedMipmappedArray
+.. autofunction:: cuda.bindings.runtime.cudaDestroyExternalMemory
+.. autofunction:: cuda.bindings.runtime.cudaImportExternalSemaphore
+.. autofunction:: cuda.bindings.runtime.cudaSignalExternalSemaphoresAsync
+.. autofunction:: cuda.bindings.runtime.cudaWaitExternalSemaphoresAsync
+.. autofunction:: cuda.bindings.runtime.cudaDestroyExternalSemaphore
+
+Execution Control
+-----------------
+
+This section describes the execution control functions of the CUDA runtime application programming interface.
+
+
+
+Some functions have overloaded C++ API template versions documented separately in the C++ API Routines module.
+
+.. autofunction:: cuda.bindings.runtime.cudaFuncSetCacheConfig
+.. autofunction:: cuda.bindings.runtime.cudaFuncSetSharedMemConfig
+.. autofunction:: cuda.bindings.runtime.cudaFuncGetAttributes
+.. autofunction:: cuda.bindings.runtime.cudaFuncSetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaLaunchHostFunc
+
+Occupancy
+---------
+
+This section describes the occupancy calculation functions of the CUDA runtime application programming interface.
+
+
+
+Besides the occupancy calculator functions (cudaOccupancyMaxActiveBlocksPerMultiprocessor and cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags), there are also C++ only occupancy-based launch configuration functions documented in C++ API Routines module.
+
+
+
+See cudaOccupancyMaxPotentialBlockSize (C++ API), cudaOccupancyMaxPotentialBlockSize (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMem (C++ API), cudaOccupancyMaxPotentialBlockSizeVariableSMem (C++ API) cudaOccupancyAvailableDynamicSMemPerBlock (C++ API),
+
+.. autofunction:: cuda.bindings.runtime.cudaOccupancyMaxActiveBlocksPerMultiprocessor
+.. autofunction:: cuda.bindings.runtime.cudaOccupancyAvailableDynamicSMemPerBlock
+.. autofunction:: cuda.bindings.runtime.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
+
+Memory Management
+-----------------
+
+This section describes the memory management functions of the CUDA runtime application programming interface.
+
+
+
+Some functions have overloaded C++ API template versions documented separately in the C++ API Routines module.
+
+.. autofunction:: cuda.bindings.runtime.cudaMallocManaged
+.. autofunction:: cuda.bindings.runtime.cudaMalloc
+.. autofunction:: cuda.bindings.runtime.cudaMallocHost
+.. autofunction:: cuda.bindings.runtime.cudaMallocPitch
+.. autofunction:: cuda.bindings.runtime.cudaMallocArray
+.. autofunction:: cuda.bindings.runtime.cudaFree
+.. autofunction:: cuda.bindings.runtime.cudaFreeHost
+.. autofunction:: cuda.bindings.runtime.cudaFreeArray
+.. autofunction:: cuda.bindings.runtime.cudaFreeMipmappedArray
+.. autofunction:: cuda.bindings.runtime.cudaHostAlloc
+.. autofunction:: cuda.bindings.runtime.cudaHostRegister
+.. autofunction:: cuda.bindings.runtime.cudaHostUnregister
+.. autofunction:: cuda.bindings.runtime.cudaHostGetDevicePointer
+.. autofunction:: cuda.bindings.runtime.cudaHostGetFlags
+.. autofunction:: cuda.bindings.runtime.cudaMalloc3D
+.. autofunction:: cuda.bindings.runtime.cudaMalloc3DArray
+.. autofunction:: cuda.bindings.runtime.cudaMallocMipmappedArray
+.. autofunction:: cuda.bindings.runtime.cudaGetMipmappedArrayLevel
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy3D
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy3DPeer
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy3DAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy3DPeerAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemGetInfo
+.. autofunction:: cuda.bindings.runtime.cudaArrayGetInfo
+.. autofunction:: cuda.bindings.runtime.cudaArrayGetPlane
+.. autofunction:: cuda.bindings.runtime.cudaArrayGetMemoryRequirements
+.. autofunction:: cuda.bindings.runtime.cudaMipmappedArrayGetMemoryRequirements
+.. autofunction:: cuda.bindings.runtime.cudaArrayGetSparseProperties
+.. autofunction:: cuda.bindings.runtime.cudaMipmappedArrayGetSparseProperties
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy
+.. autofunction:: cuda.bindings.runtime.cudaMemcpyPeer
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2D
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DToArray
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DFromArray
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DArrayToArray
+.. autofunction:: cuda.bindings.runtime.cudaMemcpyAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemcpyPeerAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DToArrayAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemcpy2DFromArrayAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemset
+.. autofunction:: cuda.bindings.runtime.cudaMemset2D
+.. autofunction:: cuda.bindings.runtime.cudaMemset3D
+.. autofunction:: cuda.bindings.runtime.cudaMemsetAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemset2DAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemset3DAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemPrefetchAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemAdvise
+.. autofunction:: cuda.bindings.runtime.cudaMemRangeGetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaMemRangeGetAttributes
+.. autofunction:: cuda.bindings.runtime.make_cudaPitchedPtr
+.. autofunction:: cuda.bindings.runtime.make_cudaPos
+.. autofunction:: cuda.bindings.runtime.make_cudaExtent
+
+Stream Ordered Memory Allocator
+-------------------------------
+
+**overview**
+
+
+
+The asynchronous allocator allows the user to allocate and free in stream order. All asynchronous accesses of the allocation must happen between the stream executions of the allocation and the free. If the memory is accessed outside of the promised stream order, a use before allocation / use after free error will cause undefined behavior.
+
+The allocator is free to reallocate the memory as long as it can guarantee that compliant memory accesses will not overlap temporally. The allocator may refer to internal stream ordering as well as inter-stream dependencies (such as CUDA events and null stream dependencies) when establishing the temporal guarantee. The allocator may also insert inter-stream dependencies to establish the temporal guarantee.
+
+
+
+
+
+**Supported Platforms**
+
+
+
+Whether or not a device supports the integrated stream ordered memory allocator may be queried by calling cudaDeviceGetAttribute() with the device attribute cudaDevAttrMemoryPoolsSupported.
+
+.. autofunction:: cuda.bindings.runtime.cudaMallocAsync
+.. autofunction:: cuda.bindings.runtime.cudaFreeAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolTrimTo
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolSetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolGetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolSetAccess
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolGetAccess
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolCreate
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolDestroy
+.. autofunction:: cuda.bindings.runtime.cudaMallocFromPoolAsync
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolExportToShareableHandle
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolImportFromShareableHandle
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolExportPointer
+.. autofunction:: cuda.bindings.runtime.cudaMemPoolImportPointer
+
+Unified Addressing
+------------------
+
+This section describes the unified addressing functions of the CUDA runtime application programming interface.
+
+
+
+
+
+**Overview**
+
+
+
+CUDA devices can share a unified address space with the host. 
+
+ For these devices there is no distinction between a device pointer and a host pointer -- the same pointer value may be used to access memory from the host program and from a kernel running on the device (with exceptions enumerated below).
+
+
+
+
+
+**Supported Platforms**
+
+
+
+Whether or not a device supports unified addressing may be queried by calling cudaGetDeviceProperties() with the device property cudaDeviceProp::unifiedAddressing.
+
+Unified addressing is automatically enabled in 64-bit processes .
+
+
+
+
+
+**Looking Up Information from Pointer Values**
+
+
+
+It is possible to look up information about the memory which backs a pointer value. For instance, one may want to know if a pointer points to host or device memory. As another example, in the case of device memory, one may want to know on which CUDA device the memory resides. These properties may be queried using the function cudaPointerGetAttributes()
+
+Since pointers are unique, it is not necessary to specify information about the pointers specified to cudaMemcpy() and other copy functions. 
+
+ The copy direction cudaMemcpyDefault may be used to specify that the CUDA runtime should infer the location of the pointer from its value.
+
+
+
+
+
+**Automatic Mapping of Host Allocated Host Memory**
+
+
+
+All host memory allocated through all devices using cudaMallocHost() and cudaHostAlloc() is always directly accessible from all devices that support unified addressing. This is the case regardless of whether or not the flags cudaHostAllocPortable and cudaHostAllocMapped are specified.
+
+The pointer value through which allocated host memory may be accessed in kernels on all devices that support unified addressing is the same as the pointer value through which that memory is accessed on the host. It is not necessary to call cudaHostGetDevicePointer() to get the device pointer for these allocations. 
+
+
+
+Note that this is not the case for memory allocated using the flag cudaHostAllocWriteCombined, as discussed below.
+
+
+
+
+
+**Direct Access of Peer Memory**
+
+
+
+Upon enabling direct access from a device that supports unified addressing to another peer device that supports unified addressing using cudaDeviceEnablePeerAccess() all memory allocated in the peer device using cudaMalloc() and cudaMallocPitch() will immediately be accessible by the current device. The device pointer value through which any peer's memory may be accessed in the current device is the same pointer value through which that memory may be accessed from the peer device.
+
+
+
+
+
+**Exceptions, Disjoint Addressing**
+
+
+
+Not all memory may be accessed on devices through the same pointer value through which they are accessed on the host. These exceptions are host memory registered using cudaHostRegister() and host memory allocated using the flag cudaHostAllocWriteCombined. For these exceptions, there exists a distinct host and device address for the memory. The device address is guaranteed to not overlap any valid host pointer range and is guaranteed to have the same value across all devices that support unified addressing. 
+
+
+
+This device address may be queried using cudaHostGetDevicePointer() when a device using unified addressing is current. Either the host or the unified device pointer value may be used to refer to this memory in cudaMemcpy() and similar functions using the cudaMemcpyDefault memory direction.
+
+.. autofunction:: cuda.bindings.runtime.cudaPointerGetAttributes
+
+Peer Device Memory Access
+-------------------------
+
+This section describes the peer device memory access functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaDeviceCanAccessPeer
+.. autofunction:: cuda.bindings.runtime.cudaDeviceEnablePeerAccess
+.. autofunction:: cuda.bindings.runtime.cudaDeviceDisablePeerAccess
+
+OpenGL Interoperability
+-----------------------
+
+impl_private
+
+
+
+This section describes the OpenGL interoperability functions of the CUDA runtime application programming interface. Note that mapping of OpenGL resources is performed with the graphics API agnostic, resource mapping interface described in Graphics Interopability.
+
+.. autoclass:: cuda.bindings.runtime.cudaGLDeviceList
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGLDeviceList.cudaGLDeviceListAll
+
+
+        The CUDA devices for all GPUs used by the current OpenGL context
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGLDeviceList.cudaGLDeviceListCurrentFrame
+
+
+        The CUDA devices for the GPUs used by the current OpenGL context in its currently rendering frame
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGLDeviceList.cudaGLDeviceListNextFrame
+
+
+        The CUDA devices for the GPUs to be used by the current OpenGL context in the next frame
+
+.. autofunction:: cuda.bindings.runtime.cudaGLGetDevices
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsGLRegisterImage
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsGLRegisterBuffer
+
+Direct3D 9 Interoperability
+---------------------------
+
+
+
+
+Direct3D 10 Interoperability
+----------------------------
+
+
+
+
+Direct3D 11 Interoperability
+----------------------------
+
+
+
+
+VDPAU Interoperability
+----------------------
+
+This section describes the VDPAU interoperability functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaVDPAUGetDevice
+.. autofunction:: cuda.bindings.runtime.cudaVDPAUSetVDPAUDevice
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsVDPAURegisterVideoSurface
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsVDPAURegisterOutputSurface
+
+EGL Interoperability
+--------------------
+
+This section describes the EGL interoperability functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsEGLRegisterImage
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamConsumerConnect
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamConsumerConnectWithFlags
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamConsumerDisconnect
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamConsumerAcquireFrame
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamConsumerReleaseFrame
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamProducerConnect
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamProducerDisconnect
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamProducerPresentFrame
+.. autofunction:: cuda.bindings.runtime.cudaEGLStreamProducerReturnFrame
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsResourceGetMappedEglFrame
+.. autofunction:: cuda.bindings.runtime.cudaEventCreateFromEGLSync
+
+Graphics Interoperability
+-------------------------
+
+This section describes the graphics interoperability functions of the CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsUnregisterResource
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsResourceSetMapFlags
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsMapResources
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsUnmapResources
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsResourceGetMappedPointer
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsSubResourceGetMappedArray
+.. autofunction:: cuda.bindings.runtime.cudaGraphicsResourceGetMappedMipmappedArray
+
+Texture Object Management
+-------------------------
+
+This section describes the low level texture object management functions of the CUDA runtime application programming interface. The texture object API is only supported on devices of compute capability 3.0 or higher.
+
+.. autofunction:: cuda.bindings.runtime.cudaGetChannelDesc
+.. autofunction:: cuda.bindings.runtime.cudaCreateChannelDesc
+.. autofunction:: cuda.bindings.runtime.cudaCreateTextureObject
+.. autofunction:: cuda.bindings.runtime.cudaCreateTextureObject_v2
+.. autofunction:: cuda.bindings.runtime.cudaDestroyTextureObject
+.. autofunction:: cuda.bindings.runtime.cudaGetTextureObjectResourceDesc
+.. autofunction:: cuda.bindings.runtime.cudaGetTextureObjectTextureDesc
+.. autofunction:: cuda.bindings.runtime.cudaGetTextureObjectTextureDesc_v2
+.. autofunction:: cuda.bindings.runtime.cudaGetTextureObjectResourceViewDesc
+
+Surface Object Management
+-------------------------
+
+This section describes the low level texture object management functions of the CUDA runtime application programming interface. The surface object API is only supported on devices of compute capability 3.0 or higher.
+
+.. autofunction:: cuda.bindings.runtime.cudaCreateSurfaceObject
+.. autofunction:: cuda.bindings.runtime.cudaDestroySurfaceObject
+.. autofunction:: cuda.bindings.runtime.cudaGetSurfaceObjectResourceDesc
+
+Version Management
+------------------
+
+
+
+.. autofunction:: cuda.bindings.runtime.cudaDriverGetVersion
+.. autofunction:: cuda.bindings.runtime.cudaRuntimeGetVersion
+.. autofunction:: cuda.bindings.runtime.getLocalRuntimeVersion
+
+Graph Management
+----------------
+
+This section describes the graph management functions of CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaGraphCreate
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddKernelNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphKernelNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphKernelNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphKernelNodeCopyAttributes
+.. autofunction:: cuda.bindings.runtime.cudaGraphKernelNodeGetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaGraphKernelNodeSetAttribute
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddMemcpyNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddMemcpyNode1D
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemcpyNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemcpyNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemcpyNodeSetParams1D
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddMemsetNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemsetNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemsetNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddHostNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphHostNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphHostNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddChildGraphNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphChildGraphNodeGetGraph
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddEmptyNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddEventRecordNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphEventRecordNodeGetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphEventRecordNodeSetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddEventWaitNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphEventWaitNodeGetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphEventWaitNodeSetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddExternalSemaphoresSignalNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphExternalSemaphoresSignalNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExternalSemaphoresSignalNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddExternalSemaphoresWaitNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphExternalSemaphoresWaitNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExternalSemaphoresWaitNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddMemAllocNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemAllocNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddMemFreeNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphMemFreeNodeGetParams
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGraphMemTrim
+.. autofunction:: cuda.bindings.runtime.cudaDeviceGetGraphMemAttribute
+.. autofunction:: cuda.bindings.runtime.cudaDeviceSetGraphMemAttribute
+.. autofunction:: cuda.bindings.runtime.cudaGraphClone
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeFindInClone
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeGetType
+.. autofunction:: cuda.bindings.runtime.cudaGraphGetNodes
+.. autofunction:: cuda.bindings.runtime.cudaGraphGetRootNodes
+.. autofunction:: cuda.bindings.runtime.cudaGraphGetEdges
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeGetDependencies
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeGetDependentNodes
+.. autofunction:: cuda.bindings.runtime.cudaGraphAddDependencies
+.. autofunction:: cuda.bindings.runtime.cudaGraphRemoveDependencies
+.. autofunction:: cuda.bindings.runtime.cudaGraphDestroyNode
+.. autofunction:: cuda.bindings.runtime.cudaGraphInstantiate
+.. autofunction:: cuda.bindings.runtime.cudaGraphInstantiateWithFlags
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecKernelNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecMemcpyNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecMemcpyNodeSetParams1D
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecMemsetNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecHostNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecChildGraphNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecEventRecordNodeSetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecEventWaitNodeSetEvent
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecExternalSemaphoresSignalNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecExternalSemaphoresWaitNodeSetParams
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeSetEnabled
+.. autofunction:: cuda.bindings.runtime.cudaGraphNodeGetEnabled
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecUpdate
+.. autofunction:: cuda.bindings.runtime.cudaGraphUpload
+.. autofunction:: cuda.bindings.runtime.cudaGraphLaunch
+.. autofunction:: cuda.bindings.runtime.cudaGraphExecDestroy
+.. autofunction:: cuda.bindings.runtime.cudaGraphDestroy
+.. autofunction:: cuda.bindings.runtime.cudaGraphDebugDotPrint
+.. autofunction:: cuda.bindings.runtime.cudaUserObjectCreate
+.. autofunction:: cuda.bindings.runtime.cudaUserObjectRetain
+.. autofunction:: cuda.bindings.runtime.cudaUserObjectRelease
+.. autofunction:: cuda.bindings.runtime.cudaGraphRetainUserObject
+.. autofunction:: cuda.bindings.runtime.cudaGraphReleaseUserObject
+
+Driver Entry Point Access
+-------------------------
+
+This section describes the driver entry point access functions of CUDA runtime application programming interface.
+
+.. autofunction:: cuda.bindings.runtime.cudaGetDriverEntryPoint
+
+C++ API Routines
+----------------
+C++-style interface built on top of CUDA runtime API.
+impl_private
+
+
+
+
+
+
+
+This section describes the C++ high level API functions of the CUDA runtime application programming interface. To use these functions, your application needs to be compiled with the ``nvcc``\  compiler.
+
+
+Interactions with the CUDA Driver API
+-------------------------------------
+
+This section describes the interactions between the CUDA Driver API and the CUDA Runtime API
+
+
+
+
+
+**Primary Contexts**
+
+
+
+There exists a one to one relationship between CUDA devices in the CUDA Runtime API and ::CUcontext s in the CUDA Driver API within a process. The specific context which the CUDA Runtime API uses for a device is called the device's primary context. From the perspective of the CUDA Runtime API, a device and its primary context are synonymous.
+
+
+
+
+
+**Initialization and Tear-Down**
+
+
+
+CUDA Runtime API calls operate on the CUDA Driver API ::CUcontext which is current to to the calling host thread. 
+
+
+
+The function cudaSetDevice() makes the primary context for the specified device current to the calling thread by calling ::cuCtxSetCurrent().
+
+The CUDA Runtime API will automatically initialize the primary context for a device at the first CUDA Runtime API call which requires an active context. If no ::CUcontext is current to the calling thread when a CUDA Runtime API call which requires an active context is made, then the primary context for a device will be selected, made current to the calling thread, and initialized.
+
+The context which the CUDA Runtime API initializes will be initialized using the parameters specified by the CUDA Runtime API functions cudaSetDeviceFlags(), ::cudaD3D9SetDirect3DDevice(), ::cudaD3D10SetDirect3DDevice(), ::cudaD3D11SetDirect3DDevice(), cudaGLSetGLDevice(), and cudaVDPAUSetVDPAUDevice(). Note that these functions will fail with cudaErrorSetOnActiveProcess if they are called when the primary context for the specified device has already been initialized. (or if the current device has already been initialized, in the case of cudaSetDeviceFlags()).
+
+Primary contexts will remain active until they are explicitly deinitialized using cudaDeviceReset(). The function cudaDeviceReset() will deinitialize the primary context for the calling thread's current device immediately. The context will remain current to all of the threads that it was current to. The next CUDA Runtime API call on any thread which requires an active context will trigger the reinitialization of that device's primary context.
+
+Note that primary contexts are shared resources. It is recommended that the primary context not be reset except just before exit or to recover from an unspecified launch failure.
+
+
+
+
+
+**Context Interoperability**
+
+
+
+Note that the use of multiple ::CUcontext s per device within a single process will substantially degrade performance and is strongly discouraged. Instead, it is highly recommended that the implicit one-to-one device-to-context mapping for the process provided by the CUDA Runtime API be used.
+
+If a non-primary ::CUcontext created by the CUDA Driver API is current to a thread then the CUDA Runtime API calls to that thread will operate on that ::CUcontext, with some exceptions listed below. Interoperability between data types is discussed in the following sections.
+
+The function cudaPointerGetAttributes() will return the error cudaErrorIncompatibleDriverContext if the pointer being queried was allocated by a non-primary context. The function cudaDeviceEnablePeerAccess() and the rest of the peer access API may not be called when a non-primary ::CUcontext is current. 
+
+ To use the pointer query and peer access APIs with a context created using the CUDA Driver API, it is necessary that the CUDA Driver API be used to access these features.
+
+All CUDA Runtime API state (e.g, global variables' addresses and values) travels with its underlying ::CUcontext. In particular, if a ::CUcontext is moved from one thread to another then all CUDA Runtime API state will move to that thread as well.
+
+Please note that attaching to legacy contexts (those with a version of 3010 as returned by ::cuCtxGetApiVersion()) is not possible. The CUDA Runtime will return cudaErrorIncompatibleDriverContext in such cases.
+
+
+
+
+
+**Interactions between CUstream and cudaStream_t**
+
+
+
+The types ::CUstream and cudaStream_t are identical and may be used interchangeably.
+
+
+
+
+
+**Interactions between CUevent and cudaEvent_t**
+
+
+
+The types ::CUevent and cudaEvent_t are identical and may be used interchangeably.
+
+
+
+
+
+**Interactions between CUarray and cudaArray_t**
+
+
+
+The types ::CUarray and struct ::cudaArray * represent the same data type and may be used interchangeably by casting the two types between each other.
+
+In order to use a ::CUarray in a CUDA Runtime API function which takes a struct ::cudaArray *, it is necessary to explicitly cast the ::CUarray to a struct ::cudaArray *.
+
+In order to use a struct ::cudaArray * in a CUDA Driver API function which takes a ::CUarray, it is necessary to explicitly cast the struct ::cudaArray * to a ::CUarray .
+
+
+
+
+
+**Interactions between CUgraphicsResource and cudaGraphicsResource_t**
+
+
+
+The types ::CUgraphicsResource and cudaGraphicsResource_t represent the same data type and may be used interchangeably by casting the two types between each other.
+
+In order to use a ::CUgraphicsResource in a CUDA Runtime API function which takes a cudaGraphicsResource_t, it is necessary to explicitly cast the ::CUgraphicsResource to a cudaGraphicsResource_t.
+
+In order to use a cudaGraphicsResource_t in a CUDA Driver API function which takes a ::CUgraphicsResource, it is necessary to explicitly cast the cudaGraphicsResource_t to a ::CUgraphicsResource.
+
+
+
+
+
+**Interactions between CUtexObject and cudaTextureObject_t**
+
+
+
+The types ::CUtexObject and cudaTextureObject_t represent the same data type and may be used interchangeably by casting the two types between each other.
+
+In order to use a ::CUtexObject in a CUDA Runtime API function which takes a cudaTextureObject_t, it is necessary to explicitly cast the ::CUtexObject to a cudaTextureObject_t.
+
+In order to use a cudaTextureObject_t in a CUDA Driver API function which takes a ::CUtexObject, it is necessary to explicitly cast the cudaTextureObject_t to a ::CUtexObject.
+
+
+
+
+
+**Interactions between CUsurfObject and cudaSurfaceObject_t**
+
+
+
+The types ::CUsurfObject and cudaSurfaceObject_t represent the same data type and may be used interchangeably by casting the two types between each other.
+
+In order to use a ::CUsurfObject in a CUDA Runtime API function which takes a cudaSurfaceObject_t, it is necessary to explicitly cast the ::CUsurfObject to a cudaSurfaceObject_t.
+
+In order to use a cudaSurfaceObject_t in a CUDA Driver API function which takes a ::CUsurfObject, it is necessary to explicitly cast the cudaSurfaceObject_t to a ::CUsurfObject.
+
+
+
+
+
+**Interactions between CUfunction and cudaFunction_t**
+
+
+
+The types ::CUfunction and cudaFunction_t represent the same data type and may be used interchangeably by casting the two types between each other.
+
+In order to use a cudaFunction_t in a CUDA Driver API function which takes a ::CUfunction, it is necessary to explicitly cast the cudaFunction_t to a ::CUfunction.
+
+
+Data types used by CUDA Runtime
+-------------------------------
+
+
+
+.. autoclass:: cuda.bindings.runtime.cudaEglPlaneDesc_st
+.. autoclass:: cuda.bindings.runtime.cudaEglFrame_st
+.. autoclass:: cuda.bindings.runtime.cudaChannelFormatDesc
+.. autoclass:: cuda.bindings.runtime.cudaArraySparseProperties
+.. autoclass:: cuda.bindings.runtime.cudaArrayMemoryRequirements
+.. autoclass:: cuda.bindings.runtime.cudaPitchedPtr
+.. autoclass:: cuda.bindings.runtime.cudaExtent
+.. autoclass:: cuda.bindings.runtime.cudaPos
+.. autoclass:: cuda.bindings.runtime.cudaMemcpy3DParms
+.. autoclass:: cuda.bindings.runtime.cudaMemcpy3DPeerParms
+.. autoclass:: cuda.bindings.runtime.cudaMemsetParams
+.. autoclass:: cuda.bindings.runtime.cudaAccessPolicyWindow
+.. autoclass:: cuda.bindings.runtime.cudaHostNodeParams
+.. autoclass:: cuda.bindings.runtime.cudaResourceDesc
+.. autoclass:: cuda.bindings.runtime.cudaResourceViewDesc
+.. autoclass:: cuda.bindings.runtime.cudaPointerAttributes
+.. autoclass:: cuda.bindings.runtime.cudaFuncAttributes
+.. autoclass:: cuda.bindings.runtime.cudaMemLocation
+.. autoclass:: cuda.bindings.runtime.cudaMemAccessDesc
+.. autoclass:: cuda.bindings.runtime.cudaMemPoolProps
+.. autoclass:: cuda.bindings.runtime.cudaMemPoolPtrExportData
+.. autoclass:: cuda.bindings.runtime.cudaMemAllocNodeParams
+.. autoclass:: cuda.bindings.runtime.CUuuid_st
+.. autoclass:: cuda.bindings.runtime.cudaDeviceProp
+.. autoclass:: cuda.bindings.runtime.cudaIpcEventHandle_st
+.. autoclass:: cuda.bindings.runtime.cudaIpcMemHandle_st
+.. autoclass:: cuda.bindings.runtime.cudaExternalMemoryHandleDesc
+.. autoclass:: cuda.bindings.runtime.cudaExternalMemoryBufferDesc
+.. autoclass:: cuda.bindings.runtime.cudaExternalMemoryMipmappedArrayDesc
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreHandleDesc
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreSignalParams
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreWaitParams
+.. autoclass:: cuda.bindings.runtime.cudaKernelNodeParams
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreSignalNodeParams
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreWaitNodeParams
+.. autoclass:: cuda.bindings.runtime.cudaLaunchAttributeValue
+.. autoclass:: cuda.bindings.runtime.cudaLaunchAttribute_st
+.. autoclass:: cuda.bindings.runtime.cudaTextureDesc
+.. autoclass:: cuda.bindings.runtime.cudaTextureDesc_v2
+.. autoclass:: cuda.bindings.runtime.cudaEglFrameType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglFrameType.cudaEglFrameTypeArray
+
+
+        Frame type CUDA array
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglFrameType.cudaEglFrameTypePitch
+
+
+        Frame type CUDA pointer
+
+.. autoclass:: cuda.bindings.runtime.cudaEglResourceLocationFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglResourceLocationFlags.cudaEglResourceLocationSysmem
+
+
+        Resource location sysmem
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglResourceLocationFlags.cudaEglResourceLocationVidmem
+
+
+        Resource location vidmem
+
+.. autoclass:: cuda.bindings.runtime.cudaEglColorFormat
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420Planar
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420SemiPlanar
+
+
+        Y, UV in two surfaces (UV as one surface) with VU byte ordering, width, height ratio same as YUV420Planar.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV422Planar
+
+
+        Y, U, V each in a separate surface, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV422SemiPlanar
+
+
+        Y, UV in two surfaces with VU byte ordering, width, height ratio same as YUV422Planar.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatARGB
+
+
+        R/G/B/A four channels in one surface with BGRA byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatRGBA
+
+
+        R/G/B/A four channels in one surface with ABGR byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatL
+
+
+        single luminance channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatR
+
+
+        single color channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV444Planar
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV444SemiPlanar
+
+
+        Y, UV in two surfaces (UV as one surface) with VU byte ordering, width, height ratio same as YUV444Planar.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUYV422
+
+
+        Y, U, V in one surface, interleaved as UYVY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatUYVY422
+
+
+        Y, U, V in one surface, interleaved as YUYV in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatABGR
+
+
+        R/G/B/A four channels in one surface with RGBA byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBGRA
+
+
+        R/G/B/A four channels in one surface with ARGB byte ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatA
+
+
+        Alpha color format - one channel in one surface.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatRG
+
+
+        R/G color format - two channels in one surface with GR byte ordering
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatAYUV
+
+
+        Y, U, V, A four channels in one surface, interleaved as VUYA.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU444SemiPlanar
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU422SemiPlanar
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420SemiPlanar
+
+
+        Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_444SemiPlanar
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_420SemiPlanar
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_444SemiPlanar
+
+
+        Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_420SemiPlanar
+
+
+        Y12, V12U12 in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatVYUY_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as YVYU in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatUYVY_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as YUYV in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUYV_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as UYVY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVYU_ER
+
+
+        Extended Range Y, U, V in one surface, interleaved as VYUY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUVA_ER
+
+
+        Extended Range Y, U, V, A four channels in one surface, interleaved as AVUY.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatAYUV_ER
+
+
+        Extended Range Y, U, V, A four channels in one surface, interleaved as VUYA.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV444Planar_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV422Planar_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420Planar_ER
+
+
+        Extended Range Y, U, V in three surfaces, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV444SemiPlanar_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV422SemiPlanar_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420SemiPlanar_ER
+
+
+        Extended Range Y, UV in two surfaces (UV as one surface) with VU byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU444Planar_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU422Planar_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420Planar_ER
+
+
+        Extended Range Y, V, U in three surfaces, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU444SemiPlanar_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU422SemiPlanar_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420SemiPlanar_ER
+
+
+        Extended Range Y, VU in two surfaces (VU as one surface) with UV byte ordering, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerRGGB
+
+
+        Bayer format - one channel in one surface with interleaved RGGB ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerBGGR
+
+
+        Bayer format - one channel in one surface with interleaved BGGR ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerGRBG
+
+
+        Bayer format - one channel in one surface with interleaved GRBG ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerGBRG
+
+
+        Bayer format - one channel in one surface with interleaved GBRG ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer10RGGB
+
+
+        Bayer10 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer10BGGR
+
+
+        Bayer10 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer10GRBG
+
+
+        Bayer10 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer10GBRG
+
+
+        Bayer10 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12RGGB
+
+
+        Bayer12 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12BGGR
+
+
+        Bayer12 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12GRBG
+
+
+        Bayer12 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12GBRG
+
+
+        Bayer12 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer14RGGB
+
+
+        Bayer14 format - one channel in one surface with interleaved RGGB ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer14BGGR
+
+
+        Bayer14 format - one channel in one surface with interleaved BGGR ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer14GRBG
+
+
+        Bayer14 format - one channel in one surface with interleaved GRBG ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer14GBRG
+
+
+        Bayer14 format - one channel in one surface with interleaved GBRG ordering. Out of 16 bits, 14 bits used 2 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer20RGGB
+
+
+        Bayer20 format - one channel in one surface with interleaved RGGB ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer20BGGR
+
+
+        Bayer20 format - one channel in one surface with interleaved BGGR ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer20GRBG
+
+
+        Bayer20 format - one channel in one surface with interleaved GRBG ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer20GBRG
+
+
+        Bayer20 format - one channel in one surface with interleaved GBRG ordering. Out of 32 bits, 20 bits used 12 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU444Planar
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU422Planar
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420Planar
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerIspRGGB
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved RGGB ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerIspBGGR
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved BGGR ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerIspGRBG
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved GRBG ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerIspGBRG
+
+
+        Nvidia proprietary Bayer ISP format - one channel in one surface with interleaved GBRG ordering and mapped to opaque integer datatype.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerBCCR
+
+
+        Bayer format - one channel in one surface with interleaved BCCR ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerRCCB
+
+
+        Bayer format - one channel in one surface with interleaved RCCB ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerCRBC
+
+
+        Bayer format - one channel in one surface with interleaved CRBC ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayerCBRC
+
+
+        Bayer format - one channel in one surface with interleaved CBRC ordering.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer10CCCC
+
+
+        Bayer10 format - one channel in one surface with interleaved CCCC ordering. Out of 16 bits, 10 bits used 6 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12BCCR
+
+
+        Bayer12 format - one channel in one surface with interleaved BCCR ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12RCCB
+
+
+        Bayer12 format - one channel in one surface with interleaved RCCB ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12CRBC
+
+
+        Bayer12 format - one channel in one surface with interleaved CRBC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12CBRC
+
+
+        Bayer12 format - one channel in one surface with interleaved CBRC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatBayer12CCCC
+
+
+        Bayer12 format - one channel in one surface with interleaved CCCC ordering. Out of 16 bits, 12 bits used 4 bits No-op.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY
+
+
+        Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420SemiPlanar_2020
+
+
+        Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420SemiPlanar_2020
+
+
+        Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420Planar_2020
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420Planar_2020
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420SemiPlanar_709
+
+
+        Y, UV in two surfaces (UV as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420SemiPlanar_709
+
+
+        Y, VU in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUV420Planar_709
+
+
+        Y, U, V in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVU420Planar_709
+
+
+        Y, V, U in three surfaces, each in a separate surface, U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_420SemiPlanar_709
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_420SemiPlanar_2020
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_422SemiPlanar_2020
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_422SemiPlanar
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_422SemiPlanar_709
+
+
+        Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY_ER
+
+
+        Extended Range Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY_709_ER
+
+
+        Extended Range Color format for single Y plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10_ER
+
+
+        Extended Range Color format for single Y10 plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10_709_ER
+
+
+        Extended Range Color format for single Y10 plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12_ER
+
+
+        Extended Range Color format for single Y12 plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12_709_ER
+
+
+        Extended Range Color format for single Y12 plane.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYUVA
+
+
+        Y, U, V, A four channels in one surface, interleaved as AVUY.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatYVYU
+
+
+        Y, U, V in one surface, interleaved as YVYU in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatVYUY
+
+
+        Y, U, V in one surface, interleaved as VYUY in one channel.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_420SemiPlanar_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_420SemiPlanar_709_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_444SemiPlanar_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY10V10U10_444SemiPlanar_709_ER
+
+
+        Extended Range Y10, V10U10 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_420SemiPlanar_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_420SemiPlanar_709_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = 1/2 Y width, U/V height = 1/2 Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_444SemiPlanar_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaEglColorFormat.cudaEglColorFormatY12V12U12_444SemiPlanar_709_ER
+
+
+        Extended Range Y12, V12U12 in two surfaces (VU as one surface) U/V width = Y width, U/V height = Y height.
+
+.. autoclass:: cuda.bindings.runtime.cudaError_t
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaSuccess
+
+
+        The API call returned with no errors. In the case of query calls, this also means that the operation being queried is complete (see :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`).
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidValue
+
+
+        This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMemoryAllocation
+
+
+        The API call failed because it was unable to allocate enough memory to perform the requested operation.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInitializationError
+
+
+        The API call failed because the CUDA driver and runtime could not be initialized.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorCudartUnloading
+
+
+        This indicates that a CUDA Runtime API call cannot be executed because it is being called during process shut down, at a point in time after CUDA driver has been unloaded.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorProfilerDisabled
+
+
+        This indicates profiler is not initialized for this run. This can happen when the application is running with external profiling tools like visual profiler.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorProfilerNotInitialized
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorProfilerAlreadyStarted
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorProfilerAlreadyStopped
+
+
+        [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidConfiguration
+
+
+        This indicates that a kernel launch is requesting resources that can never be satisfied by the current device. Requesting more shared memory per block than the device supports will trigger this error, as will requesting too many threads or blocks. See :py:obj:`~.cudaDeviceProp` for more device limitations.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidPitchValue
+
+
+        This indicates that one or more of the pitch-related parameters passed to the API call is not within the acceptable range for pitch.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidSymbol
+
+
+        This indicates that the symbol name/identifier passed to the API call is not a valid name or identifier.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidHostPointer
+
+
+        This indicates that at least one host pointer passed to the API call is not a valid host pointer. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidDevicePointer
+
+
+        This indicates that at least one device pointer passed to the API call is not a valid device pointer. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidTexture
+
+
+        This indicates that the texture passed to the API call is not a valid texture.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidTextureBinding
+
+
+        This indicates that the texture binding is not valid. This occurs if you call :py:obj:`~.cudaGetTextureAlignmentOffset()` with an unbound texture.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidChannelDescriptor
+
+
+        This indicates that the channel descriptor passed to the API call is not valid. This occurs if the format is not one of the formats specified by :py:obj:`~.cudaChannelFormatKind`, or if one of the dimensions is invalid.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidMemcpyDirection
+
+
+        This indicates that the direction of the memcpy passed to the API call is not one of the types specified by :py:obj:`~.cudaMemcpyKind`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorAddressOfConstant
+
+
+        This indicated that the user has taken the address of a constant variable, which was forbidden up until the CUDA 3.1 release. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorTextureFetchFailed
+
+
+        This indicated that a texture fetch was not able to be performed. This was previously used for device emulation of texture operations. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorTextureNotBound
+
+
+        This indicated that a texture was not bound for access. This was previously used for device emulation of texture operations. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSynchronizationError
+
+
+        This indicated that a synchronization operation had failed. This was previously used for some device emulation functions. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidFilterSetting
+
+
+        This indicates that a non-float texture was being accessed with linear filtering. This is not supported by CUDA.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidNormSetting
+
+
+        This indicates that an attempt was made to read a non-float texture as a normalized float. This is not supported by CUDA.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMixedDeviceExecution
+
+
+        Mixing of device and device emulation code was not allowed. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotYetImplemented
+
+
+        This indicates that the API call is not yet implemented. Production releases of CUDA will never return this error. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMemoryValueTooLarge
+
+
+        This indicated that an emulated device pointer exceeded the 32-bit address range. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStubLibrary
+
+
+        This indicates that the CUDA driver that the application has loaded is a stub library. Applications that run with the stub rather than a real driver loaded will result in CUDA API returning this error.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInsufficientDriver
+
+
+        This indicates that the installed NVIDIA CUDA driver is older than the CUDA runtime library. This is not a supported configuration. Users should install an updated NVIDIA display driver to allow the application to run.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorCallRequiresNewerDriver
+
+
+        This indicates that the API call requires a newer CUDA driver than the one currently installed. Users should install an updated NVIDIA CUDA driver to allow the API call to succeed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidSurface
+
+
+        This indicates that the surface passed to the API call is not a valid surface.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDuplicateVariableName
+
+
+        This indicates that multiple global or constant variables (across separate CUDA source files in the application) share the same string name.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDuplicateTextureName
+
+
+        This indicates that multiple textures (across separate CUDA source files in the application) share the same string name.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDuplicateSurfaceName
+
+
+        This indicates that multiple surfaces (across separate CUDA source files in the application) share the same string name.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDevicesUnavailable
+
+
+        This indicates that all CUDA devices are busy or unavailable at the current time. Devices are often busy/unavailable due to use of :py:obj:`~.cudaComputeModeProhibited`, :py:obj:`~.cudaComputeModeExclusiveProcess`, or when long running CUDA kernels have filled up the GPU and are blocking new work from starting. They can also be unavailable due to memory constraints on a device that already has active CUDA work being performed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorIncompatibleDriverContext
+
+
+        This indicates that the current context is not compatible with this the CUDA Runtime. This can only occur if you are using CUDA Runtime/Driver interoperability and have created an existing Driver context using the driver API. The Driver context may be incompatible either because the Driver context was created using an older version of the API, because the Runtime API call expects a primary driver context and the Driver context is not primary, or because the Driver context has been destroyed. Please see :py:obj:`~.Interactions`with the CUDA Driver API" for more information.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMissingConfiguration
+
+
+        The device function being invoked (usually via :py:obj:`~.cudaLaunchKernel()`) was not previously configured via the :py:obj:`~.cudaConfigureCall()` function.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorPriorLaunchFailure
+
+
+        This indicated that a previous kernel launch failed. This was previously used for device emulation of kernel launches. [Deprecated]
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchMaxDepthExceeded
+
+
+        This error indicates that a device runtime grid launch did not occur because the depth of the child grid would exceed the maximum supported number of nested grid launches.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchFileScopedTex
+
+
+        This error indicates that a grid launch did not occur because the kernel uses file-scoped textures which are unsupported by the device runtime. Kernels launched via the device runtime only support textures created with the Texture Object API's.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchFileScopedSurf
+
+
+        This error indicates that a grid launch did not occur because the kernel uses file-scoped surfaces which are unsupported by the device runtime. Kernels launched via the device runtime only support surfaces created with the Surface Object API's.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSyncDepthExceeded
+
+
+        This error indicates that a call to :py:obj:`~.cudaDeviceSynchronize` made from the device runtime failed because the call was made at grid depth greater than than either the default (2 levels of grids) or user specified device limit :py:obj:`~.cudaLimitDevRuntimeSyncDepth`. To be able to synchronize on launched grids at a greater depth successfully, the maximum nested depth at which :py:obj:`~.cudaDeviceSynchronize` will be called must be specified with the :py:obj:`~.cudaLimitDevRuntimeSyncDepth` limit to the :py:obj:`~.cudaDeviceSetLimit` api before the host-side launch of a kernel using the device runtime. Keep in mind that additional levels of sync depth require the runtime to reserve large amounts of device memory that cannot be used for user allocations.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchPendingCountExceeded
+
+
+        This error indicates that a device runtime grid launch failed because the launch would exceed the limit :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount`. For this launch to proceed successfully, :py:obj:`~.cudaDeviceSetLimit` must be called to set the :py:obj:`~.cudaLimitDevRuntimePendingLaunchCount` to be higher than the upper bound of outstanding launches that can be issued to the device runtime. Keep in mind that raising the limit of pending device runtime launches will require the runtime to reserve device memory that cannot be used for user allocations.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidDeviceFunction
+
+
+        The requested device function does not exist or is not compiled for the proper device architecture.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNoDevice
+
+
+        This indicates that no CUDA-capable devices were detected by the installed CUDA driver.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidDevice
+
+
+        This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device or that the action requested is invalid for the specified device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDeviceNotLicensed
+
+
+        This indicates that the device doesn't have a valid Grid License.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSoftwareValidityNotEstablished
+
+
+        By default, the CUDA runtime may perform a minimal set of self-tests, as well as CUDA driver tests, to establish the validity of both. Introduced in CUDA 11.2, this error return indicates that at least one of these tests has failed and the validity of either the runtime or the driver could not be established.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStartupFailure
+
+
+        This indicates an internal startup failure in the CUDA runtime.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidKernelImage
+
+
+        This indicates that the device kernel image is invalid.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDeviceUninitialized
+
+
+        This most frequently indicates that there is no context bound to the current thread. This can also be returned if the context passed to an API call is not a valid handle (such as a context that has had :py:obj:`~.cuCtxDestroy()` invoked on it). This can also be returned if a user mixes different API versions (i.e. 3010 context with 3020 API calls). See :py:obj:`~.cuCtxGetApiVersion()` for more details.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMapBufferObjectFailed
+
+
+        This indicates that the buffer object could not be mapped.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorUnmapBufferObjectFailed
+
+
+        This indicates that the buffer object could not be unmapped.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorArrayIsMapped
+
+
+        This indicates that the specified array is currently mapped and thus cannot be destroyed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorAlreadyMapped
+
+
+        This indicates that the resource is already mapped.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNoKernelImageForDevice
+
+
+        This indicates that there is no kernel image available that is suitable for the device. This can occur when a user specifies code generation options for a particular CUDA source file that do not include the corresponding device configuration.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorAlreadyAcquired
+
+
+        This indicates that a resource has already been acquired.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotMapped
+
+
+        This indicates that a resource is not mapped.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotMappedAsArray
+
+
+        This indicates that a mapped resource is not available for access as an array.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotMappedAsPointer
+
+
+        This indicates that a mapped resource is not available for access as a pointer.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorECCUncorrectable
+
+
+        This indicates that an uncorrectable ECC error was detected during execution.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorUnsupportedLimit
+
+
+        This indicates that the :py:obj:`~.cudaLimit` passed to the API call is not supported by the active device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorDeviceAlreadyInUse
+
+
+        This indicates that a call tried to access an exclusive-thread device that is already in use by a different thread.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorPeerAccessUnsupported
+
+
+        This error indicates that P2P access is not supported across the given devices.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidPtx
+
+
+        A PTX compilation failed. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidGraphicsContext
+
+
+        This indicates an error with the OpenGL or DirectX context.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNvlinkUncorrectable
+
+
+        This indicates that an uncorrectable NVLink error was detected during the execution.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorJitCompilerNotFound
+
+
+        This indicates that the PTX JIT compiler library was not found. The JIT Compiler library is used for PTX compilation. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorUnsupportedPtxVersion
+
+
+        This indicates that the provided PTX was compiled with an unsupported toolchain. The most common reason for this, is the PTX was generated by a compiler newer than what is supported by the CUDA driver and PTX JIT compiler.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorJitCompilationDisabled
+
+
+        This indicates that the JIT compilation was disabled. The JIT compilation compiles PTX. The runtime may fall back to compiling PTX if an application does not contain a suitable binary for the current device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorUnsupportedExecAffinity
+
+
+        This indicates that the provided execution affinity is not supported by the device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidSource
+
+
+        This indicates that the device kernel source is invalid.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorFileNotFound
+
+
+        This indicates that the file specified was not found.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSharedObjectSymbolNotFound
+
+
+        This indicates that a link to a shared object failed to resolve.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSharedObjectInitFailed
+
+
+        This indicates that initialization of a shared object failed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorOperatingSystem
+
+
+        This error indicates that an OS call failed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidResourceHandle
+
+
+        This indicates that a resource handle passed to the API call was not valid. Resource handles are opaque types like :py:obj:`~.cudaStream_t` and :py:obj:`~.cudaEvent_t`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorIllegalState
+
+
+        This indicates that a resource required by the API call is not in a valid state to perform the requested operation.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSymbolNotFound
+
+
+        This indicates that a named symbol was not found. Examples of symbols are global/constant variable names, driver function names, texture names, and surface names.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotReady
+
+
+        This indicates that asynchronous operations issued previously have not completed yet. This result is not actually an error, but must be indicated differently than :py:obj:`~.cudaSuccess` (which indicates completion). Calls that may return this value include :py:obj:`~.cudaEventQuery()` and :py:obj:`~.cudaStreamQuery()`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorIllegalAddress
+
+
+        The device encountered a load or store instruction on an invalid memory address. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchOutOfResources
+
+
+        This indicates that a launch did not occur because it did not have appropriate resources. Although this error is similar to :py:obj:`~.cudaErrorInvalidConfiguration`, this error usually indicates that the user has attempted to pass too many arguments to the device kernel, or the kernel launch specifies too many threads for the kernel's register count.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchTimeout
+
+
+        This indicates that the device kernel took too long to execute. This can only occur if timeouts are enabled - see the device property :py:obj:`~.kernelExecTimeoutEnabled` for more information. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchIncompatibleTexturing
+
+
+        This error indicates a kernel launch that uses an incompatible texturing mode.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorPeerAccessAlreadyEnabled
+
+
+        This error indicates that a call to :py:obj:`~.cudaDeviceEnablePeerAccess()` is trying to re-enable peer addressing on from a context which has already had peer addressing enabled.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorPeerAccessNotEnabled
+
+
+        This error indicates that :py:obj:`~.cudaDeviceDisablePeerAccess()` is trying to disable peer addressing which has not been enabled yet via :py:obj:`~.cudaDeviceEnablePeerAccess()`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSetOnActiveProcess
+
+
+        This indicates that the user has called :py:obj:`~.cudaSetValidDevices()`, :py:obj:`~.cudaSetDeviceFlags()`, :py:obj:`~.cudaD3D9SetDirect3DDevice()`, :py:obj:`~.cudaD3D10SetDirect3DDevice`, :py:obj:`~.cudaD3D11SetDirect3DDevice()`, or :py:obj:`~.cudaVDPAUSetVDPAUDevice()` after initializing the CUDA runtime by calling non-device management operations (allocating memory and launching kernels are examples of non-device management operations). This error can also be returned if using runtime/driver interoperability and there is an existing :py:obj:`~.CUcontext` active on the host thread.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorContextIsDestroyed
+
+
+        This error indicates that the context current to the calling thread has been destroyed using :py:obj:`~.cuCtxDestroy`, or is a primary context which has not yet been initialized.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorAssert
+
+
+        An assert triggered in device code during kernel execution. The device cannot be used again. All existing allocations are invalid. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorTooManyPeers
+
+
+        This error indicates that the hardware resources required to enable peer access have been exhausted for one or more of the devices passed to :py:obj:`~.cudaEnablePeerAccess()`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorHostMemoryAlreadyRegistered
+
+
+        This error indicates that the memory range passed to :py:obj:`~.cudaHostRegister()` has already been registered.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorHostMemoryNotRegistered
+
+
+        This error indicates that the pointer passed to :py:obj:`~.cudaHostUnregister()` does not correspond to any currently registered memory region.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorHardwareStackError
+
+
+        Device encountered an error in the call stack during kernel execution, possibly due to stack corruption or exceeding the stack size limit. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorIllegalInstruction
+
+
+        The device encountered an illegal instruction during kernel execution This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMisalignedAddress
+
+
+        The device encountered a load or store instruction on a memory address which is not aligned. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidAddressSpace
+
+
+        While executing a kernel, the device encountered an instruction which can only operate on memory locations in certain address spaces (global, shared, or local), but was supplied a memory address not belonging to an allowed address space. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidPc
+
+
+        The device encountered an invalid program counter. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorLaunchFailure
+
+
+        An exception occurred on the device while executing a kernel. Common causes include dereferencing an invalid device pointer and accessing out of bounds shared memory. Less common cases can be system specific - more information about these cases can be found in the system specific user guide. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorCooperativeLaunchTooLarge
+
+
+        This error indicates that the number of blocks launched per grid for a kernel that was launched via either :py:obj:`~.cudaLaunchCooperativeKernel` or :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice` exceeds the maximum number of blocks as allowed by :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessor` or :py:obj:`~.cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags` times the number of multiprocessors as specified by the device attribute :py:obj:`~.cudaDevAttrMultiProcessorCount`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotPermitted
+
+
+        This error indicates the attempted operation is not permitted.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorNotSupported
+
+
+        This error indicates the attempted operation is not supported on the current system or device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSystemNotReady
+
+
+        This error indicates that the system is not yet ready to start any CUDA work. To continue using CUDA, verify the system configuration is in a valid state and all required driver daemons are actively running. More information about this error can be found in the system specific user guide.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorSystemDriverMismatch
+
+
+        This error indicates that there is a mismatch between the versions of the display driver and the CUDA driver. Refer to the compatibility documentation for supported versions.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorCompatNotSupportedOnDevice
+
+
+        This error indicates that the system was upgraded to run with forward compatibility but the visible hardware detected by CUDA does not support this configuration. Refer to the compatibility documentation for the supported hardware matrix or ensure that only supported hardware is visible during initialization via the CUDA_VISIBLE_DEVICES environment variable.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsConnectionFailed
+
+
+        This error indicates that the MPS client failed to connect to the MPS control daemon or the MPS server.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsRpcFailure
+
+
+        This error indicates that the remote procedural call between the MPS server and the MPS client failed.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsServerNotReady
+
+
+        This error indicates that the MPS server is not ready to accept new MPS client requests. This error can be returned when the MPS server is in the process of recovering from a fatal failure.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsMaxClientsReached
+
+
+        This error indicates that the hardware resources required to create MPS client have been exhausted.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsMaxConnectionsReached
+
+
+        This error indicates the the hardware resources required to device connections have been exhausted.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorMpsClientTerminated
+
+
+        This error indicates that the MPS client has been terminated by the server. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureUnsupported
+
+
+        The operation is not permitted when the stream is capturing.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureInvalidated
+
+
+        The current capture sequence on the stream has been invalidated due to a previous error.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureMerge
+
+
+        The operation would have resulted in a merge of two independent capture sequences.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureUnmatched
+
+
+        The capture was not initiated in this stream.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureUnjoined
+
+
+        The capture sequence contains a fork that was not joined to the primary stream.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureIsolation
+
+
+        A dependency would have been created which crosses the capture sequence boundary. Only implicit in-stream ordering dependencies are allowed to cross the boundary.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureImplicit
+
+
+        The operation would have resulted in a disallowed implicit dependency on a current capture sequence from cudaStreamLegacy.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorCapturedEvent
+
+
+        The operation is not permitted on an event which was last recorded in a capturing stream.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorStreamCaptureWrongThread
+
+
+        A stream capture sequence not initiated with the :py:obj:`~.cudaStreamCaptureModeRelaxed` argument to :py:obj:`~.cudaStreamBeginCapture` was passed to :py:obj:`~.cudaStreamEndCapture` in a different thread.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorTimeout
+
+
+        This indicates that the wait operation has timed out.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorGraphExecUpdateFailure
+
+
+        This error indicates that the graph update was not performed because it included changes which violated constraints specific to instantiated graph update.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorExternalDevice
+
+
+        This indicates that an async error has occurred in a device outside of CUDA. If CUDA was waiting for an external device's signal before consuming shared data, the external device signaled an error indicating that the data is not valid for consumption. This leaves the process in an inconsistent state and any further CUDA work will return the same error. To continue using CUDA, the process must be terminated and relaunched.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorInvalidClusterSize
+
+
+        This indicates that a kernel launch error has occurred due to cluster misconfiguration.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorUnknown
+
+
+        This indicates that an unknown internal error has occurred.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaError_t.cudaErrorApiFailureBase
+
+
+        Any unhandled CUDA driver error is added to this value and returned via the runtime. Production releases of CUDA should not return such errors. [Deprecated]
+
+.. autoclass:: cuda.bindings.runtime.cudaChannelFormatKind
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSigned
+
+
+        Signed channel format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsigned
+
+
+        Unsigned channel format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindFloat
+
+
+        Float channel format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindNone
+
+
+        No channel format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindNV12
+
+
+        Unsigned 8-bit integers, planar 4:2:0 YUV format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X1
+
+
+        1 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X2
+
+
+        2 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized8X4
+
+
+        4 channel unsigned 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X1
+
+
+        1 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X2
+
+
+        2 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedNormalized16X4
+
+
+        4 channel unsigned 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X1
+
+
+        1 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X2
+
+
+        2 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized8X4
+
+
+        4 channel signed 8-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X1
+
+
+        1 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X2
+
+
+        2 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedNormalized16X4
+
+
+        4 channel signed 16-bit normalized integer
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1
+
+
+        4 channel unsigned normalized block-compressed (BC1 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed1SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC1 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2
+
+
+        4 channel unsigned normalized block-compressed (BC2 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed2SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC2 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3
+
+
+        4 channel unsigned normalized block-compressed (BC3 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed3SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC3 compression) format with sRGB encoding
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed4
+
+
+        1 channel unsigned normalized block-compressed (BC4 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed4
+
+
+        1 channel signed normalized block-compressed (BC4 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed5
+
+
+        2 channel unsigned normalized block-compressed (BC5 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed5
+
+
+        2 channel signed normalized block-compressed (BC5 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed6H
+
+
+        3 channel unsigned half-float block-compressed (BC6H compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindSignedBlockCompressed6H
+
+
+        3 channel signed half-float block-compressed (BC6H compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7
+
+
+        4 channel unsigned normalized block-compressed (BC7 compression) format
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaChannelFormatKind.cudaChannelFormatKindUnsignedBlockCompressed7SRGB
+
+
+        4 channel unsigned normalized block-compressed (BC7 compression) format with sRGB encoding
+
+.. autoclass:: cuda.bindings.runtime.cudaMemoryType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryType.cudaMemoryTypeUnregistered
+
+
+        Unregistered memory
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryType.cudaMemoryTypeHost
+
+
+        Host memory
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryType.cudaMemoryTypeDevice
+
+
+        Device memory
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryType.cudaMemoryTypeManaged
+
+
+        Managed memory
+
+.. autoclass:: cuda.bindings.runtime.cudaMemcpyKind
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemcpyKind.cudaMemcpyHostToHost
+
+
+        Host -> Host
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemcpyKind.cudaMemcpyHostToDevice
+
+
+        Host -> Device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemcpyKind.cudaMemcpyDeviceToHost
+
+
+        Device -> Host
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemcpyKind.cudaMemcpyDeviceToDevice
+
+
+        Device -> Device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemcpyKind.cudaMemcpyDefault
+
+
+        Direction of the transfer is inferred from the pointer values. Requires unified virtual addressing
+
+.. autoclass:: cuda.bindings.runtime.cudaAccessProperty
+
+    .. autoattribute:: cuda.bindings.runtime.cudaAccessProperty.cudaAccessPropertyNormal
+
+
+        Normal cache persistence.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaAccessProperty.cudaAccessPropertyStreaming
+
+
+        Streaming access is less likely to persit from cache.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaAccessProperty.cudaAccessPropertyPersisting
+
+
+        Persisting access is more likely to persist in cache.
+
+.. autoclass:: cuda.bindings.runtime.cudaStreamCaptureStatus
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureStatus.cudaStreamCaptureStatusNone
+
+
+        Stream is not capturing
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureStatus.cudaStreamCaptureStatusActive
+
+
+        Stream is actively capturing
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureStatus.cudaStreamCaptureStatusInvalidated
+
+
+        Stream is part of a capture sequence that has been invalidated, but not terminated
+
+.. autoclass:: cuda.bindings.runtime.cudaStreamCaptureMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureMode.cudaStreamCaptureModeGlobal
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureMode.cudaStreamCaptureModeThreadLocal
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamCaptureMode.cudaStreamCaptureModeRelaxed
+
+.. autoclass:: cuda.bindings.runtime.cudaSynchronizationPolicy
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSynchronizationPolicy.cudaSyncPolicyAuto
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSynchronizationPolicy.cudaSyncPolicySpin
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSynchronizationPolicy.cudaSyncPolicyYield
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSynchronizationPolicy.cudaSyncPolicyBlockingSync
+
+.. autoclass:: cuda.bindings.runtime.cudaClusterSchedulingPolicy
+
+    .. autoattribute:: cuda.bindings.runtime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyDefault
+
+
+        the default policy
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicySpread
+
+
+        spread the blocks within a cluster to the SMs
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaClusterSchedulingPolicy.cudaClusterSchedulingPolicyLoadBalancing
+
+
+        allow the hardware to load-balance the blocks in a cluster to the SMs
+
+.. autoclass:: cuda.bindings.runtime.cudaStreamUpdateCaptureDependenciesFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamAddCaptureDependencies
+
+
+        Add new nodes to the dependency set
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaStreamUpdateCaptureDependenciesFlags.cudaStreamSetCaptureDependencies
+
+
+        Replace the dependency set with the new nodes
+
+.. autoclass:: cuda.bindings.runtime.cudaUserObjectFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaUserObjectFlags.cudaUserObjectNoDestructorSync
+
+
+        Indicates the destructor execution is not synchronized by any CUDA handle.
+
+.. autoclass:: cuda.bindings.runtime.cudaUserObjectRetainFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaUserObjectRetainFlags.cudaGraphUserObjectMove
+
+
+        Transfer references from the caller rather than creating new references.
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphicsRegisterFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsNone
+
+
+        Default
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsReadOnly
+
+
+        CUDA will not write to this resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsWriteDiscard
+
+
+        CUDA will only write to and will not read from this resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsSurfaceLoadStore
+
+
+        CUDA will bind this resource to a surface reference
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsRegisterFlags.cudaGraphicsRegisterFlagsTextureGather
+
+
+        CUDA will perform texture gather operations on this resource
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphicsMapFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsNone
+
+
+        Default; Assume resource can be read/written
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsReadOnly
+
+
+        CUDA will not write to this resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsMapFlags.cudaGraphicsMapFlagsWriteDiscard
+
+
+        CUDA will only write to and will not read from this resource
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphicsCubeFace
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveX
+
+
+        Positive X face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeX
+
+
+        Negative X face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveY
+
+
+        Positive Y face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeY
+
+
+        Negative Y face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFacePositiveZ
+
+
+        Positive Z face of cubemap
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphicsCubeFace.cudaGraphicsCubeFaceNegativeZ
+
+
+        Negative Z face of cubemap
+
+.. autoclass:: cuda.bindings.runtime.cudaResourceType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceType.cudaResourceTypeArray
+
+
+        Array resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceType.cudaResourceTypeMipmappedArray
+
+
+        Mipmapped array resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceType.cudaResourceTypeLinear
+
+
+        Linear resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceType.cudaResourceTypePitch2D
+
+
+        Pitch 2D resource
+
+.. autoclass:: cuda.bindings.runtime.cudaResourceViewFormat
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatNone
+
+
+        No resource view format (use underlying resource format)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar1
+
+
+        1 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar2
+
+
+        2 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedChar4
+
+
+        4 channel unsigned 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedChar1
+
+
+        1 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedChar2
+
+
+        2 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedChar4
+
+
+        4 channel signed 8-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort1
+
+
+        1 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort2
+
+
+        2 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedShort4
+
+
+        4 channel unsigned 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedShort1
+
+
+        1 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedShort2
+
+
+        2 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedShort4
+
+
+        4 channel signed 16-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt1
+
+
+        1 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt2
+
+
+        2 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedInt4
+
+
+        4 channel unsigned 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedInt1
+
+
+        1 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedInt2
+
+
+        2 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedInt4
+
+
+        4 channel signed 32-bit integers
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatHalf1
+
+
+        1 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatHalf2
+
+
+        2 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatHalf4
+
+
+        4 channel 16-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatFloat1
+
+
+        1 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatFloat2
+
+
+        2 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatFloat4
+
+
+        4 channel 32-bit floating point
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed1
+
+
+        Block compressed 1
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed2
+
+
+        Block compressed 2
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed3
+
+
+        Block compressed 3
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed4
+
+
+        Block compressed 4 unsigned
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed4
+
+
+        Block compressed 4 signed
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed5
+
+
+        Block compressed 5 unsigned
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed5
+
+
+        Block compressed 5 signed
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed6H
+
+
+        Block compressed 6 unsigned half-float
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatSignedBlockCompressed6H
+
+
+        Block compressed 6 signed half-float
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaResourceViewFormat.cudaResViewFormatUnsignedBlockCompressed7
+
+
+        Block compressed 7
+
+.. autoclass:: cuda.bindings.runtime.cudaFuncAttribute
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeMaxDynamicSharedMemorySize
+
+
+        Maximum dynamic shared memory size
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributePreferredSharedMemoryCarveout
+
+
+        Preferred shared memory-L1 cache split
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeClusterDimMustBeSet
+
+
+        Indicator to enforce valid cluster dimension specification on kernel launch
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterWidth
+
+
+        Required cluster width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterHeight
+
+
+        Required cluster height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeRequiredClusterDepth
+
+
+        Required cluster depth
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeNonPortableClusterSizeAllowed
+
+
+        Whether non-portable cluster scheduling policy is supported
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeClusterSchedulingPolicyPreference
+
+
+        Required cluster scheduling policy preference
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncAttribute.cudaFuncAttributeMax
+
+.. autoclass:: cuda.bindings.runtime.cudaFuncCache
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncCache.cudaFuncCachePreferNone
+
+
+        Default function cache configuration, no preference
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncCache.cudaFuncCachePreferShared
+
+
+        Prefer larger shared memory and smaller L1 cache
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncCache.cudaFuncCachePreferL1
+
+
+        Prefer larger L1 cache and smaller shared memory
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFuncCache.cudaFuncCachePreferEqual
+
+
+        Prefer equal size L1 cache and shared memory
+
+.. autoclass:: cuda.bindings.runtime.cudaSharedMemConfig
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedMemConfig.cudaSharedMemBankSizeDefault
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedMemConfig.cudaSharedMemBankSizeFourByte
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedMemConfig.cudaSharedMemBankSizeEightByte
+
+.. autoclass:: cuda.bindings.runtime.cudaSharedCarveout
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedCarveout.cudaSharedmemCarveoutDefault
+
+
+        No preference for shared memory or L1 (default)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedCarveout.cudaSharedmemCarveoutMaxShared
+
+
+        Prefer maximum available shared memory, minimum L1 cache
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSharedCarveout.cudaSharedmemCarveoutMaxL1
+
+
+        Prefer maximum available L1 cache, minimum shared memory
+
+.. autoclass:: cuda.bindings.runtime.cudaComputeMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaComputeMode.cudaComputeModeDefault
+
+
+        Default compute mode (Multiple threads can use :py:obj:`~.cudaSetDevice()` with this device)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaComputeMode.cudaComputeModeExclusive
+
+
+        Compute-exclusive-thread mode (Only one thread in one process will be able to use :py:obj:`~.cudaSetDevice()` with this device)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaComputeMode.cudaComputeModeProhibited
+
+
+        Compute-prohibited mode (No threads can use :py:obj:`~.cudaSetDevice()` with this device)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaComputeMode.cudaComputeModeExclusiveProcess
+
+
+        Compute-exclusive-process mode (Many threads in one process will be able to use :py:obj:`~.cudaSetDevice()` with this device)
+
+.. autoclass:: cuda.bindings.runtime.cudaLimit
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitStackSize
+
+
+        GPU thread stack size
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitPrintfFifoSize
+
+
+        GPU printf FIFO size
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitMallocHeapSize
+
+
+        GPU malloc heap size
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitDevRuntimeSyncDepth
+
+
+        GPU device runtime synchronize depth
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitDevRuntimePendingLaunchCount
+
+
+        GPU device runtime pending launch count
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitMaxL2FetchGranularity
+
+
+        A value between 0 and 128 that indicates the maximum fetch granularity of L2 (in Bytes). This is a hint
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLimit.cudaLimitPersistingL2CacheSize
+
+
+        A size in bytes for L2 persisting lines cache size
+
+.. autoclass:: cuda.bindings.runtime.cudaMemoryAdvise
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseSetReadMostly
+
+
+        Data will mostly be read and only occassionally be written to
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseUnsetReadMostly
+
+
+        Undo the effect of :py:obj:`~.cudaMemAdviseSetReadMostly`
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseSetPreferredLocation
+
+
+        Set the preferred location for the data as the specified device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseUnsetPreferredLocation
+
+
+        Clear the preferred location for the data
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseSetAccessedBy
+
+
+        Data will be accessed by the specified device, so prevent page faults as much as possible
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemoryAdvise.cudaMemAdviseUnsetAccessedBy
+
+
+        Let the Unified Memory subsystem decide on the page faulting policy for the specified device
+
+.. autoclass:: cuda.bindings.runtime.cudaMemRangeAttribute
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemRangeAttribute.cudaMemRangeAttributeReadMostly
+
+
+        Whether the range will mostly be read and only occassionally be written to
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemRangeAttribute.cudaMemRangeAttributePreferredLocation
+
+
+        The preferred location of the range
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemRangeAttribute.cudaMemRangeAttributeAccessedBy
+
+
+        Memory range has :py:obj:`~.cudaMemAdviseSetAccessedBy` set for specified device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemRangeAttribute.cudaMemRangeAttributeLastPrefetchLocation
+
+
+        The last location to which the range was prefetched
+
+.. autoclass:: cuda.bindings.runtime.cudaOutputMode_t
+
+    .. autoattribute:: cuda.bindings.runtime.cudaOutputMode_t.cudaKeyValuePair
+
+
+        Output mode Key-Value pair format.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaOutputMode_t.cudaCSV
+
+
+        Output mode Comma separated values format.
+
+.. autoclass:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesOptions
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionHost
+
+
+        :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` and its CUDA Driver API counterpart are supported on the device.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesOptions.cudaFlushGPUDirectRDMAWritesOptionMemOps
+
+
+        The :py:obj:`~.CU_STREAM_WAIT_VALUE_FLUSH` flag and the :py:obj:`~.CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES` MemOp are supported on the CUDA device.
+
+.. autoclass:: cuda.bindings.runtime.cudaGPUDirectRDMAWritesOrdering
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingNone
+
+
+        The device does not natively support ordering of GPUDirect RDMA writes. :py:obj:`~.cudaFlushGPUDirectRDMAWrites()` can be leveraged if supported.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingOwner
+
+
+        Natively, the device can consistently consume GPUDirect RDMA writes, although other CUDA devices may not.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGPUDirectRDMAWritesOrdering.cudaGPUDirectRDMAWritesOrderingAllDevices
+
+
+        Any CUDA device in the system can consistently consume GPUDirect RDMA writes to this device.
+
+.. autoclass:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesScope
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToOwner
+
+
+        Blocks until remote writes are visible to the CUDA device context owning the data.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesScope.cudaFlushGPUDirectRDMAWritesToAllDevices
+
+
+        Blocks until remote writes are visible to all CUDA device contexts.
+
+.. autoclass:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesTarget
+
+    .. autoattribute:: cuda.bindings.runtime.cudaFlushGPUDirectRDMAWritesTarget.cudaFlushGPUDirectRDMAWritesTargetCurrentDevice
+
+
+        Sets the target for :py:obj:`~.cudaDeviceFlushGPUDirectRDMAWrites()` to the currently active CUDA device context.
+
+.. autoclass:: cuda.bindings.runtime.cudaDeviceAttr
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerBlock
+
+
+        Maximum number of threads per block
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxBlockDimX
+
+
+        Maximum block dimension X
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxBlockDimY
+
+
+        Maximum block dimension Y
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxBlockDimZ
+
+
+        Maximum block dimension Z
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxGridDimX
+
+
+        Maximum grid dimension X
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxGridDimY
+
+
+        Maximum grid dimension Y
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxGridDimZ
+
+
+        Maximum grid dimension Z
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlock
+
+
+        Maximum shared memory available per block in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrTotalConstantMemory
+
+
+        Memory available on device for constant variables in a CUDA C kernel in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrWarpSize
+
+
+        Warp size in threads
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxPitch
+
+
+        Maximum pitch in bytes allowed by memory copies
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerBlock
+
+
+        Maximum number of 32-bit registers available per block
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrClockRate
+
+
+        Peak clock frequency in kilohertz
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrTextureAlignment
+
+
+        Alignment requirement for textures
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGpuOverlap
+
+
+        Device can possibly copy memory and execute a kernel concurrently
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMultiProcessorCount
+
+
+        Number of multiprocessors on device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrKernelExecTimeout
+
+
+        Specifies whether there is a run time limit on kernels
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrIntegrated
+
+
+        Device is integrated with host memory
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrCanMapHostMemory
+
+
+        Device can map host memory into CUDA address space
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrComputeMode
+
+
+        Compute mode (See :py:obj:`~.cudaComputeMode` for details)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture1DWidth
+
+
+        Maximum 1D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DWidth
+
+
+        Maximum 2D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DHeight
+
+
+        Maximum 2D texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidth
+
+
+        Maximum 3D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeight
+
+
+        Maximum 3D texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepth
+
+
+        Maximum 3D texture depth
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredWidth
+
+
+        Maximum 2D layered texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredHeight
+
+
+        Maximum 2D layered texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLayeredLayers
+
+
+        Maximum layers in a 2D layered texture
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrSurfaceAlignment
+
+
+        Alignment requirement for surfaces
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrConcurrentKernels
+
+
+        Device can possibly execute multiple kernels concurrently
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrEccEnabled
+
+
+        Device has ECC support enabled
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrPciBusId
+
+
+        PCI bus ID of the device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrPciDeviceId
+
+
+        PCI device ID of the device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrTccDriver
+
+
+        Device is using TCC driver model
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMemoryClockRate
+
+
+        Peak memory clock frequency in kilohertz
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGlobalMemoryBusWidth
+
+
+        Global memory bus width in bits
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrL2CacheSize
+
+
+        Size of L2 cache in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxThreadsPerMultiProcessor
+
+
+        Maximum resident threads per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrAsyncEngineCount
+
+
+        Number of asynchronous engines
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrUnifiedAddressing
+
+
+        Device shares a unified address space with the host
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredWidth
+
+
+        Maximum 1D layered texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLayeredLayers
+
+
+        Maximum layers in a 1D layered texture
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherWidth
+
+
+        Maximum 2D texture width if cudaArrayTextureGather is set
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DGatherHeight
+
+
+        Maximum 2D texture height if cudaArrayTextureGather is set
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DWidthAlt
+
+
+        Alternate maximum 3D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DHeightAlt
+
+
+        Alternate maximum 3D texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture3DDepthAlt
+
+
+        Alternate maximum 3D texture depth
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrPciDomainId
+
+
+        PCI domain ID of the device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrTexturePitchAlignment
+
+
+        Pitch alignment requirement for textures
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapWidth
+
+
+        Maximum cubemap texture width/height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredWidth
+
+
+        Maximum cubemap layered texture width/height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTextureCubemapLayeredLayers
+
+
+        Maximum layers in a cubemap layered texture
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface1DWidth
+
+
+        Maximum 1D surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface2DWidth
+
+
+        Maximum 2D surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface2DHeight
+
+
+        Maximum 2D surface height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface3DWidth
+
+
+        Maximum 3D surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface3DHeight
+
+
+        Maximum 3D surface height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface3DDepth
+
+
+        Maximum 3D surface depth
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredWidth
+
+
+        Maximum 1D layered surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface1DLayeredLayers
+
+
+        Maximum layers in a 1D layered surface
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredWidth
+
+
+        Maximum 2D layered surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredHeight
+
+
+        Maximum 2D layered surface height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurface2DLayeredLayers
+
+
+        Maximum layers in a 2D layered surface
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapWidth
+
+
+        Maximum cubemap surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredWidth
+
+
+        Maximum cubemap layered surface width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSurfaceCubemapLayeredLayers
+
+
+        Maximum layers in a cubemap layered surface
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture1DLinearWidth
+
+
+        Maximum 1D linear texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearWidth
+
+
+        Maximum 2D linear texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearHeight
+
+
+        Maximum 2D linear texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DLinearPitch
+
+
+        Maximum 2D linear texture pitch in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedWidth
+
+
+        Maximum mipmapped 2D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture2DMipmappedHeight
+
+
+        Maximum mipmapped 2D texture height
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMajor
+
+
+        Major compute capability version number
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrComputeCapabilityMinor
+
+
+        Minor compute capability version number
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTexture1DMipmappedWidth
+
+
+        Maximum mipmapped 1D texture width
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrStreamPrioritiesSupported
+
+
+        Device supports stream priorities
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGlobalL1CacheSupported
+
+
+        Device supports caching globals in L1
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrLocalL1CacheSupported
+
+
+        Device supports caching locals in L1
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerMultiprocessor
+
+
+        Maximum shared memory available per multiprocessor in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxRegistersPerMultiprocessor
+
+
+        Maximum number of 32-bit registers available per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrManagedMemory
+
+
+        Device can allocate managed memory on this system
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrIsMultiGpuBoard
+
+
+        Device is on a multi-GPU board
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMultiGpuBoardGroupID
+
+
+        Unique identifier for a group of devices on the same multi-GPU board
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrHostNativeAtomicSupported
+
+
+        Link between the device and the host supports native atomic operations
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrSingleToDoublePrecisionPerfRatio
+
+
+        Ratio of single precision performance (in floating-point operations per second) to double precision performance
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccess
+
+
+        Device supports coherently accessing pageable memory without calling cudaHostRegister on it
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrConcurrentManagedAccess
+
+
+        Device can coherently access managed memory concurrently with the CPU
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrComputePreemptionSupported
+
+
+        Device supports Compute Preemption
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrCanUseHostPointerForRegisteredMem
+
+
+        Device can access host registered memory at the same virtual address as the CPU
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrReserved92
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrReserved93
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrReserved94
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrCooperativeLaunch
+
+
+        Device supports launching cooperative kernels via :py:obj:`~.cudaLaunchCooperativeKernel`
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrCooperativeMultiDeviceLaunch
+
+
+        Deprecated, cudaLaunchCooperativeKernelMultiDevice is deprecated.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxSharedMemoryPerBlockOptin
+
+
+        The maximum optin shared memory per block. This value may vary by chip. See :py:obj:`~.cudaFuncSetAttribute`
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrCanFlushRemoteWrites
+
+
+        Device supports flushing of outstanding remote writes.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrHostRegisterSupported
+
+
+        Device supports host memory registration via :py:obj:`~.cudaHostRegister`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrPageableMemoryAccessUsesHostPageTables
+
+
+        Device accesses pageable memory via the host's page tables.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrDirectManagedMemAccessFromHost
+
+
+        Host can directly access managed memory on the device without migration.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxBlocksPerMultiprocessor
+
+
+        Maximum number of blocks per multiprocessor
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxPersistingL2CacheSize
+
+
+        Maximum L2 persisting lines capacity setting in bytes.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxAccessPolicyWindowSize
+
+
+        Maximum value of :py:obj:`~.cudaAccessPolicyWindow.num_bytes`.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrReservedSharedMemoryPerBlock
+
+
+        Shared memory reserved by CUDA driver per block in bytes
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrSparseCudaArraySupported
+
+
+        Device supports sparse CUDA arrays and sparse CUDA mipmapped arrays
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrHostRegisterReadOnlySupported
+
+
+        Device supports using the :py:obj:`~.cudaHostRegister` flag cudaHostRegisterReadOnly to register memory that must be mapped as read-only to the GPU
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrTimelineSemaphoreInteropSupported
+
+
+        External timeline semaphore interop is supported on the device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMaxTimelineSemaphoreInteropSupported
+
+
+        Deprecated, External timeline semaphore interop is supported on the device
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMemoryPoolsSupported
+
+
+        Device supports using the :py:obj:`~.cudaMallocAsync` and :py:obj:`~.cudaMemPool` family of APIs
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMASupported
+
+
+        Device supports GPUDirect RDMA APIs, like nvidia_p2p_get_pages (see https://docs.nvidia.com/cuda/gpudirect-rdma for more information)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAFlushWritesOptions
+
+
+        The returned attribute shall be interpreted as a bitmask, where the individual bits are listed in the :py:obj:`~.cudaFlushGPUDirectRDMAWritesOptions` enum
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrGPUDirectRDMAWritesOrdering
+
+
+        GPUDirect RDMA writes to the device do not need to be flushed for consumers within the scope indicated by the returned attribute. See :py:obj:`~.cudaGPUDirectRDMAWritesOrdering` for the numerical values returned here.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMemoryPoolSupportedHandleTypes
+
+
+        Handle types supported with mempool based IPC
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrClusterLaunch
+
+
+        Indicates device supports cluster launch
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrDeferredMappingCudaArraySupported
+
+
+        Device supports deferred mapping CUDA arrays and CUDA mipmapped arrays
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceAttr.cudaDevAttrMax
+
+.. autoclass:: cuda.bindings.runtime.cudaMemPoolAttr
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolReuseFollowEventDependencies
+
+
+        (value type = int) Allow cuMemAllocAsync to use memory asynchronously freed in another streams as long as a stream ordering dependency of the allocating stream on the free action exists. Cuda events and null stream interactions can create the required stream ordered dependencies. (default enabled)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolReuseAllowOpportunistic
+
+
+        (value type = int) Allow reuse of already completed frees when there is no dependency between the free and allocation. (default enabled)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolReuseAllowInternalDependencies
+
+
+        (value type = int) Allow cuMemAllocAsync to insert new stream dependencies in order to establish the stream ordering required to reuse a piece of memory released by cuFreeAsync (default enabled).
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolAttrReleaseThreshold
+
+
+        (value type = cuuint64_t) Amount of reserved memory in bytes to hold onto before trying to release memory back to the OS. When more than the release threshold bytes of memory are held by the memory pool, the allocator will try to release memory back to the OS on the next call to stream, event or context synchronize. (default 0)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemCurrent
+
+
+        (value type = cuuint64_t) Amount of backing memory currently allocated for the mempool.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolAttrReservedMemHigh
+
+
+        (value type = cuuint64_t) High watermark of backing memory allocated for the mempool since the last time it was reset. High watermark can only be reset to zero.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemCurrent
+
+
+        (value type = cuuint64_t) Amount of memory from the pool that is currently in use by the application.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemPoolAttr.cudaMemPoolAttrUsedMemHigh
+
+
+        (value type = cuuint64_t) High watermark of the amount of memory from the pool that was in use by the application since the last time it was reset. High watermark can only be reset to zero.
+
+.. autoclass:: cuda.bindings.runtime.cudaMemLocationType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemLocationType.cudaMemLocationTypeInvalid
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemLocationType.cudaMemLocationTypeDevice
+
+
+        Location is a device location, thus id is a device ordinal
+
+.. autoclass:: cuda.bindings.runtime.cudaMemAccessFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAccessFlags.cudaMemAccessFlagsProtNone
+
+
+        Default, make the address range not accessible
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAccessFlags.cudaMemAccessFlagsProtRead
+
+
+        Make the address range read accessible
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAccessFlags.cudaMemAccessFlagsProtReadWrite
+
+
+        Make the address range read-write accessible
+
+.. autoclass:: cuda.bindings.runtime.cudaMemAllocationType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationType.cudaMemAllocationTypeInvalid
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationType.cudaMemAllocationTypePinned
+
+
+        This allocation type is 'pinned', i.e. cannot migrate from its current location while the application is actively using it
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationType.cudaMemAllocationTypeMax
+
+.. autoclass:: cuda.bindings.runtime.cudaMemAllocationHandleType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationHandleType.cudaMemHandleTypeNone
+
+
+        Does not allow any export mechanism. >
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationHandleType.cudaMemHandleTypePosixFileDescriptor
+
+
+        Allows a file descriptor to be used for exporting. Permitted only on POSIX systems. (int)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32
+
+
+        Allows a Win32 NT handle to be used for exporting. (HANDLE)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaMemAllocationHandleType.cudaMemHandleTypeWin32Kmt
+
+
+        Allows a Win32 KMT handle to be used for exporting. (D3DKMT_HANDLE)
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphMemAttributeType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemCurrent
+
+
+        (value type = cuuint64_t) Amount of memory, in bytes, currently associated with graphs.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphMemAttributeType.cudaGraphMemAttrUsedMemHigh
+
+
+        (value type = cuuint64_t) High watermark of memory, in bytes, associated with graphs since the last time it was reset. High watermark can only be reset to zero.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemCurrent
+
+
+        (value type = cuuint64_t) Amount of memory, in bytes, currently allocated for use by the CUDA graphs asynchronous allocator.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphMemAttributeType.cudaGraphMemAttrReservedMemHigh
+
+
+        (value type = cuuint64_t) High watermark of memory, in bytes, currently allocated for use by the CUDA graphs asynchronous allocator.
+
+.. autoclass:: cuda.bindings.runtime.cudaDeviceP2PAttr
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceP2PAttr.cudaDevP2PAttrPerformanceRank
+
+
+        A relative value indicating the performance of the link between two devices
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceP2PAttr.cudaDevP2PAttrAccessSupported
+
+
+        Peer access is enabled
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceP2PAttr.cudaDevP2PAttrNativeAtomicSupported
+
+
+        Native atomic operation over the link supported
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaDeviceP2PAttr.cudaDevP2PAttrCudaArrayAccessSupported
+
+
+        Accessing CUDA arrays over the link supported
+
+.. autoclass:: cuda.bindings.runtime.cudaExternalMemoryHandleType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueFd
+
+
+        Handle is an opaque file descriptor
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32
+
+
+        Handle is an opaque shared NT handle
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeOpaqueWin32Kmt
+
+
+        Handle is an opaque, globally shared handle
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Heap
+
+
+        Handle is a D3D12 heap object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D12Resource
+
+
+        Handle is a D3D12 committed resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11Resource
+
+
+        Handle is a shared NT handle to a D3D11 resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeD3D11ResourceKmt
+
+
+        Handle is a globally shared handle to a D3D11 resource
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryHandleType.cudaExternalMemoryHandleTypeNvSciBuf
+
+
+        Handle is an NvSciBuf object
+
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueFd
+
+
+        Handle is an opaque file descriptor
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32
+
+
+        Handle is an opaque shared NT handle
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt
+
+
+        Handle is an opaque, globally shared handle
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D12Fence
+
+
+        Handle is a shared NT handle referencing a D3D12 fence object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeD3D11Fence
+
+
+        Handle is a shared NT handle referencing a D3D11 fence object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeNvSciSync
+
+
+        Opaque handle to NvSciSync Object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutex
+
+
+        Handle is a shared NT handle referencing a D3D11 keyed mutex object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeKeyedMutexKmt
+
+
+        Handle is a shared KMT handle referencing a D3D11 keyed mutex object
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreFd
+
+
+        Handle is an opaque handle file descriptor referencing a timeline semaphore
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreHandleType.cudaExternalSemaphoreHandleTypeTimelineSemaphoreWin32
+
+
+        Handle is an opaque handle file descriptor referencing a timeline semaphore
+
+.. autoclass:: cuda.bindings.runtime.cudaCGScope
+
+    .. autoattribute:: cuda.bindings.runtime.cudaCGScope.cudaCGScopeInvalid
+
+
+        Invalid cooperative group scope
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaCGScope.cudaCGScopeGrid
+
+
+        Scope represented by a grid_group
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaCGScope.cudaCGScopeMultiGrid
+
+
+        Scope represented by a multi_grid_group
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphNodeType
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeKernel
+
+
+        GPU kernel node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeMemcpy
+
+
+        Memcpy node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeMemset
+
+
+        Memset node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeHost
+
+
+        Host (executable) node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeGraph
+
+
+        Node which executes an embedded graph
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeEmpty
+
+
+        Empty (no-op) node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeWaitEvent
+
+
+        External event wait node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeEventRecord
+
+
+        External event record node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreSignal
+
+
+        External semaphore signal node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeExtSemaphoreWait
+
+
+        External semaphore wait node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeMemAlloc
+
+
+        Memory allocation node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeMemFree
+
+
+        Memory free node
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphNodeType.cudaGraphNodeTypeCount
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphExecUpdateResult
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateSuccess
+
+
+        The update succeeded
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateError
+
+
+        The update failed for an unexpected reason which is described in the return value of the function
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorTopologyChanged
+
+
+        The update failed because the topology changed
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNodeTypeChanged
+
+
+        The update failed because a node type changed
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorFunctionChanged
+
+
+        The update failed because the function of a kernel node changed (CUDA driver < 11.2)
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorParametersChanged
+
+
+        The update failed because the parameters changed in a way that is not supported
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorNotSupported
+
+
+        The update failed because something about the node is not supported
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorUnsupportedFunctionChange
+
+
+        The update failed because the function of a kernel node changed in an unsupported way
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphExecUpdateResult.cudaGraphExecUpdateErrorAttributesChanged
+
+
+        The update failed because the node attributes changed in a way that is not supported
+
+.. autoclass:: cuda.bindings.runtime.cudaGetDriverEntryPointFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGetDriverEntryPointFlags.cudaEnableDefault
+
+
+        Default search mode for driver symbols.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGetDriverEntryPointFlags.cudaEnableLegacyStream
+
+
+        Search for legacy versions of driver symbols.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGetDriverEntryPointFlags.cudaEnablePerThreadDefaultStream
+
+
+        Search for per-thread versions of driver symbols.
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphDebugDotFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsVerbose
+
+
+        Output all debug data as if every debug flag is enabled
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeParams
+
+
+        Adds :py:obj:`~.cudaKernelNodeParams` to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemcpyNodeParams
+
+
+        Adds :py:obj:`~.cudaMemcpy3DParms` to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsMemsetNodeParams
+
+
+        Adds :py:obj:`~.cudaMemsetParams` to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHostNodeParams
+
+
+        Adds :py:obj:`~.cudaHostNodeParams` to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsEventNodeParams
+
+
+        Adds cudaEvent_t handle from record and wait nodes to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasSignalNodeParams
+
+
+        Adds :py:obj:`~.cudaExternalSemaphoreSignalNodeParams` values to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsExtSemasWaitNodeParams
+
+
+        Adds :py:obj:`~.cudaExternalSemaphoreWaitNodeParams` to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsKernelNodeAttributes
+
+
+        Adds cudaKernelNodeAttrID values to output
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphDebugDotFlags.cudaGraphDebugDotFlagsHandles
+
+
+        Adds node handles and every kernel function handle to output
+
+.. autoclass:: cuda.bindings.runtime.cudaGraphInstantiateFlags
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagAutoFreeOnLaunch
+
+
+        Automatically free memory allocated in a graph before relaunching.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaGraphInstantiateFlags.cudaGraphInstantiateFlagUseNodePriority
+
+
+        Run the graph using the per-node priority attributes rather than the priority of the stream it is launched into.
+
+.. autoclass:: cuda.bindings.runtime.cudaLaunchAttributeID
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeIgnore
+
+
+        Ignored entry, for convenient composition
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeAccessPolicyWindow
+
+
+        Valid for streams, graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeCooperative
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeSynchronizationPolicy
+
+
+        Valid for streams.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeClusterDimension
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeClusterSchedulingPolicyPreference
+
+
+        Valid for graph nodes, launches.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticStreamSerialization
+
+
+        Valid for launches. Setting programmaticStreamSerializationAllowed to non-0 signals that the kernel will use programmatic means to resolve its stream dependency, so that the CUDA runtime should opportunistically allow the grid's execution to overlap with the previous kernel in the stream, if that kernel requests the overlap.
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributeProgrammaticEvent
+
+
+        Valid for launches. Event recorded through this launch attribute is guaranteed to only trigger after all block in the associated kernel trigger the event. A block can trigger the event through PTX griddepcontrol.launch_dependents. A trigger can also be inserted at the beginning of each block's execution if triggerAtBlockStart is set to non-0. Note that dependents (including the CPU thread calling :py:obj:`~.cudaEventSynchronize()`) are not guaranteed to observe the release precisely when it is released. For example, :py:obj:`~.cudaEventSynchronize()` may only observe the event trigger long after the associated kernel has completed. This recording type is primarily meant for establishing programmatic dependency between device tasks. The event supplied must not be an interprocess or interop event. The event must disable timing (i.e. created with :py:obj:`~.cudaEventDisableTiming` flag set).
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaLaunchAttributeID.cudaLaunchAttributePriority
+
+
+        Valid for graph nodes.
+
+.. autoclass:: cuda.bindings.runtime.cudaSurfaceBoundaryMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSurfaceBoundaryMode.cudaBoundaryModeZero
+
+
+        Zero boundary mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSurfaceBoundaryMode.cudaBoundaryModeClamp
+
+
+        Clamp boundary mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSurfaceBoundaryMode.cudaBoundaryModeTrap
+
+
+        Trap boundary mode
+
+.. autoclass:: cuda.bindings.runtime.cudaSurfaceFormatMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSurfaceFormatMode.cudaFormatModeForced
+
+
+        Forced format mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaSurfaceFormatMode.cudaFormatModeAuto
+
+
+        Auto format mode
+
+.. autoclass:: cuda.bindings.runtime.cudaTextureAddressMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureAddressMode.cudaAddressModeWrap
+
+
+        Wrapping address mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureAddressMode.cudaAddressModeClamp
+
+
+        Clamp to edge address mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureAddressMode.cudaAddressModeMirror
+
+
+        Mirror address mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureAddressMode.cudaAddressModeBorder
+
+
+        Border address mode
+
+.. autoclass:: cuda.bindings.runtime.cudaTextureFilterMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureFilterMode.cudaFilterModePoint
+
+
+        Point filter mode
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureFilterMode.cudaFilterModeLinear
+
+
+        Linear filter mode
+
+.. autoclass:: cuda.bindings.runtime.cudaTextureReadMode
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureReadMode.cudaReadModeElementType
+
+
+        Read texture as specified element type
+
+
+    .. autoattribute:: cuda.bindings.runtime.cudaTextureReadMode.cudaReadModeNormalizedFloat
+
+
+        Read texture as normalized float
+
+.. autoclass:: cuda.bindings.runtime.cudaEglPlaneDesc
+.. autoclass:: cuda.bindings.runtime.cudaEglFrame
+.. autoclass:: cuda.bindings.runtime.cudaEglStreamConnection
+.. autoclass:: cuda.bindings.runtime.cudaArray_t
+.. autoclass:: cuda.bindings.runtime.cudaArray_const_t
+.. autoclass:: cuda.bindings.runtime.cudaMipmappedArray_t
+.. autoclass:: cuda.bindings.runtime.cudaMipmappedArray_const_t
+.. autoclass:: cuda.bindings.runtime.cudaHostFn_t
+.. autoclass:: cuda.bindings.runtime.CUuuid
+.. autoclass:: cuda.bindings.runtime.cudaUUID_t
+.. autoclass:: cuda.bindings.runtime.cudaIpcEventHandle_t
+.. autoclass:: cuda.bindings.runtime.cudaIpcMemHandle_t
+.. autoclass:: cuda.bindings.runtime.cudaStream_t
+.. autoclass:: cuda.bindings.runtime.cudaEvent_t
+.. autoclass:: cuda.bindings.runtime.cudaGraphicsResource_t
+.. autoclass:: cuda.bindings.runtime.cudaExternalMemory_t
+.. autoclass:: cuda.bindings.runtime.cudaExternalSemaphore_t
+.. autoclass:: cuda.bindings.runtime.cudaGraph_t
+.. autoclass:: cuda.bindings.runtime.cudaGraphNode_t
+.. autoclass:: cuda.bindings.runtime.cudaUserObject_t
+.. autoclass:: cuda.bindings.runtime.cudaFunction_t
+.. autoclass:: cuda.bindings.runtime.cudaMemPool_t
+.. autoclass:: cuda.bindings.runtime.cudaGraphExec_t
+.. autoclass:: cuda.bindings.runtime.cudaLaunchAttributeValue
+.. autoclass:: cuda.bindings.runtime.cudaLaunchAttribute
+.. autoclass:: cuda.bindings.runtime.cudaSurfaceObject_t
+.. autoclass:: cuda.bindings.runtime.cudaTextureObject_t
+.. autoattribute:: cuda.bindings.runtime.CUDA_EGL_MAX_PLANES
+
+    Maximum number of planes per frame
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostAllocDefault
+
+    Default page-locked allocation flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostAllocPortable
+
+    Pinned memory accessible by all CUDA contexts
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostAllocMapped
+
+    Map allocation into device space
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostAllocWriteCombined
+
+    Write-combined memory
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostRegisterDefault
+
+    Default host memory registration flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostRegisterPortable
+
+    Pinned memory accessible by all CUDA contexts
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostRegisterMapped
+
+    Map registered memory into device space
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostRegisterIoMemory
+
+    Memory-mapped I/O space
+
+.. autoattribute:: cuda.bindings.runtime.cudaHostRegisterReadOnly
+
+    Memory-mapped read-only
+
+.. autoattribute:: cuda.bindings.runtime.cudaPeerAccessDefault
+
+    Default peer addressing enable flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamDefault
+
+    Default stream flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamNonBlocking
+
+    Stream does not synchronize with stream 0 (the NULL stream)
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamLegacy
+
+    Legacy stream handle
+
+
+
+    Stream handle that can be passed as a cudaStream_t to use an implicit stream with legacy synchronization behavior.
+
+
+
+    See details of the \link_sync_behavior
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamPerThread
+
+    Per-thread stream handle
+
+
+
+    Stream handle that can be passed as a cudaStream_t to use an implicit stream with per-thread synchronization behavior.
+
+
+
+    See details of the \link_sync_behavior
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventDefault
+
+    Default event flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventBlockingSync
+
+    Event uses blocking synchronization
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventDisableTiming
+
+    Event will not record timing data
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventInterprocess
+
+    Event is suitable for interprocess use. cudaEventDisableTiming must be set
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventRecordDefault
+
+    Default event record flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventRecordExternal
+
+    Event is captured in the graph as an external event node when performing stream capture
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventWaitDefault
+
+    Default event wait flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaEventWaitExternal
+
+    Event is captured in the graph as an external event node when performing stream capture
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceScheduleAuto
+
+    Device flag - Automatic scheduling
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceScheduleSpin
+
+    Device flag - Spin default scheduling
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceScheduleYield
+
+    Device flag - Yield default scheduling
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceScheduleBlockingSync
+
+    Device flag - Use blocking synchronization
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceBlockingSync
+
+    Device flag - Use blocking synchronization [Deprecated]
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceScheduleMask
+
+    Device schedule flags mask
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceMapHost
+
+    Device flag - Support mapped pinned allocations
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceLmemResizeToMax
+
+    Device flag - Keep local memory allocation after launch
+
+.. autoattribute:: cuda.bindings.runtime.cudaDeviceMask
+
+    Device flags mask
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayDefault
+
+    Default CUDA array allocation flag
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayLayered
+
+    Must be set in cudaMalloc3DArray to create a layered CUDA array
+
+.. autoattribute:: cuda.bindings.runtime.cudaArraySurfaceLoadStore
+
+    Must be set in cudaMallocArray or cudaMalloc3DArray in order to bind surfaces to the CUDA array
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayCubemap
+
+    Must be set in cudaMalloc3DArray to create a cubemap CUDA array
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayTextureGather
+
+    Must be set in cudaMallocArray or cudaMalloc3DArray in order to perform texture gather operations on the CUDA array
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayColorAttachment
+
+    Must be set in cudaExternalMemoryGetMappedMipmappedArray if the mipmapped array is used as a color target in a graphics API
+
+.. autoattribute:: cuda.bindings.runtime.cudaArraySparse
+
+    Must be set in cudaMallocArray, cudaMalloc3DArray or cudaMallocMipmappedArray in order to create a sparse CUDA array or CUDA mipmapped array
+
+.. autoattribute:: cuda.bindings.runtime.cudaArrayDeferredMapping
+
+    Must be set in cudaMallocArray, cudaMalloc3DArray or cudaMallocMipmappedArray in order to create a deferred mapping CUDA array or CUDA mipmapped array
+
+.. autoattribute:: cuda.bindings.runtime.cudaIpcMemLazyEnablePeerAccess
+
+    Automatically enable peer access between remote devices as needed
+
+.. autoattribute:: cuda.bindings.runtime.cudaMemAttachGlobal
+
+    Memory can be accessed by any stream on any device
+
+.. autoattribute:: cuda.bindings.runtime.cudaMemAttachHost
+
+    Memory cannot be accessed by any stream on any device
+
+.. autoattribute:: cuda.bindings.runtime.cudaMemAttachSingle
+
+    Memory can only be accessed by a single stream on the associated device
+
+.. autoattribute:: cuda.bindings.runtime.cudaOccupancyDefault
+
+    Default behavior
+
+.. autoattribute:: cuda.bindings.runtime.cudaOccupancyDisableCachingOverride
+
+    Assume global caching is enabled and cannot be automatically turned off
+
+.. autoattribute:: cuda.bindings.runtime.cudaCpuDeviceId
+
+    Device id that represents the CPU
+
+.. autoattribute:: cuda.bindings.runtime.cudaInvalidDeviceId
+
+    Device id that represents an invalid device
+
+.. autoattribute:: cuda.bindings.runtime.cudaCooperativeLaunchMultiDeviceNoPreSync
+
+    If set, each kernel launched as part of :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice` only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
+
+.. autoattribute:: cuda.bindings.runtime.cudaCooperativeLaunchMultiDeviceNoPostSync
+
+    If set, any subsequent work pushed in a stream that participated in a call to :py:obj:`~.cudaLaunchCooperativeKernelMultiDevice` will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
+
+.. autoattribute:: cuda.bindings.runtime.cudaArraySparsePropertiesSingleMipTail
+
+    Indicates that the layered sparse CUDA array or CUDA mipmapped array has a single mip tail region for all layers
+
+.. autoattribute:: cuda.bindings.runtime.CUDART_CB
+.. autoattribute:: cuda.bindings.runtime.CU_UUID_HAS_BEEN_DEFINED
+
+    CUDA UUID types
+
+.. autoattribute:: cuda.bindings.runtime.cudaDevicePropDontCare
+
+    Empty device properties
+
+.. autoattribute:: cuda.bindings.runtime.CUDA_IPC_HANDLE_SIZE
+
+    CUDA IPC Handle Size
+
+.. autoattribute:: cuda.bindings.runtime.cudaExternalMemoryDedicated
+
+    Indicates that the external memory object is a dedicated resource
+
+.. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreSignalSkipNvSciBufMemSync
+
+    When the /p flags parameter of :py:obj:`~.cudaExternalSemaphoreSignalParams` contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
+
+.. autoattribute:: cuda.bindings.runtime.cudaExternalSemaphoreWaitSkipNvSciBufMemSync
+
+    When the /p flags parameter of :py:obj:`~.cudaExternalSemaphoreWaitParams` contains this flag, it indicates that waiting an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as :py:obj:`~.cudaExternalMemoryHandleTypeNvSciBuf`, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
+
+.. autoattribute:: cuda.bindings.runtime.cudaNvSciSyncAttrSignal
+
+    When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to this, it indicates that application need signaler specific NvSciSyncAttr to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`.
+
+.. autoattribute:: cuda.bindings.runtime.cudaNvSciSyncAttrWait
+
+    When /p flags of :py:obj:`~.cudaDeviceGetNvSciSyncAttributes` is set to this, it indicates that application need waiter specific NvSciSyncAttr to be filled by :py:obj:`~.cudaDeviceGetNvSciSyncAttributes`.
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamAttrID
+
+    Stream Attributes
+
+.. autoattribute:: cuda.bindings.runtime.cudaStreamAttributeAccessPolicyWindow
+.. autoattribute:: cuda.bindings.runtime.cudaStreamAttributeSynchronizationPolicy
+.. autoattribute:: cuda.bindings.runtime.cudaStreamAttrValue
+
+    Stream attributes union used with :py:obj:`~.cudaStreamSetAttribute`/:py:obj:`~.cudaStreamGetAttribute`
+
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttrID
+
+    Graph kernel node Attributes
+
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttributeAccessPolicyWindow
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttributeCooperative
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttributePriority
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttributeClusterDimension
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttributeClusterSchedulingPolicyPreference
+.. autoattribute:: cuda.bindings.runtime.cudaKernelNodeAttrValue
+
+    Graph kernel node attributes union, used with :py:obj:`~.cudaGraphKernelNodeSetAttribute`/:py:obj:`~.cudaGraphKernelNodeGetAttribute`
+
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceType1D
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceType2D
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceType3D
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceTypeCubemap
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceType1DLayered
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceType2DLayered
+.. autoattribute:: cuda.bindings.runtime.cudaSurfaceTypeCubemapLayered
+.. autoattribute:: cuda.bindings.runtime.cudaTextureType1D
+.. autoattribute:: cuda.bindings.runtime.cudaTextureType2D
+.. autoattribute:: cuda.bindings.runtime.cudaTextureType3D
+.. autoattribute:: cuda.bindings.runtime.cudaTextureTypeCubemap
+.. autoattribute:: cuda.bindings.runtime.cudaTextureType1DLayered
+.. autoattribute:: cuda.bindings.runtime.cudaTextureType2DLayered
+.. autoattribute:: cuda.bindings.runtime.cudaTextureTypeCubemapLayered
diff --git a/docs_src/source/release/11.8.1-notes.md b/docs_src/source/release/11.8.1-notes.md
index cb1aebf8..3d8d9da5 100644
--- a/docs_src/source/release/11.8.1-notes.md
+++ b/docs_src/source/release/11.8.1-notes.md
@@ -1,6 +1,6 @@
 # CUDA Python 11.8.1 Release notes
 
-Released on November 4, 2022
+Released on October ??, 2022
 
 ## Hightlights
 - Resolves [issue #27](https://github.com/NVIDIA/cuda-python/issues/24)
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index e3bd7463..00000000
--- a/setup.cfg
+++ /dev/null
@@ -1,12 +0,0 @@
-# See the docstring in versioneer.py for instructions. Note that you must
-# re-run 'versioneer.py setup' after changing this section, and commit the
-# resulting files.
-
-[versioneer]
-VCS = git
-style = pep440
-versionfile_source = cuda/_version.py
-versionfile_build = cuda/_version.py
-tag_prefix = v
-parentdir_prefix = cuda-python-
-